class IRB::Context

# File irb/context.rb, line 27
    def initialize(irb, workspace = nil, input_method = nil)
      @irb = irb
      @workspace_stack = []
      if workspace
        @workspace_stack << workspace
      else
        @workspace_stack << WorkSpace.new
      end
      @thread = Thread.current

      # copy of default configuration
      @ap_name = IRB.conf[:AP_NAME]
      @rc = IRB.conf[:RC]
      @load_modules = IRB.conf[:LOAD_MODULES]

      if IRB.conf.has_key?(:USE_SINGLELINE)
        @use_singleline = IRB.conf[:USE_SINGLELINE]
      elsif IRB.conf.has_key?(:USE_READLINE) # backward compatibility
        @use_singleline = IRB.conf[:USE_READLINE]
      else
        @use_singleline = nil
      end
      if IRB.conf.has_key?(:USE_MULTILINE)
        @use_multiline = IRB.conf[:USE_MULTILINE]
      elsif IRB.conf.has_key?(:USE_RELINE) # backward compatibility
        warn <<~MSG.strip
          USE_RELINE is deprecated, please use USE_MULTILINE instead.
        MSG
        @use_multiline = IRB.conf[:USE_RELINE]
      elsif IRB.conf.has_key?(:USE_REIDLINE)
        warn <<~MSG.strip
          USE_REIDLINE is deprecated, please use USE_MULTILINE instead.
        MSG
        @use_multiline = IRB.conf[:USE_REIDLINE]
      else
        @use_multiline = nil
      end
      @use_autocomplete = IRB.conf[:USE_AUTOCOMPLETE]
      @verbose = IRB.conf[:VERBOSE]
      @io = nil

      self.inspect_mode = IRB.conf[:INSPECT_MODE]
      self.use_tracer = IRB.conf[:USE_TRACER]
      self.use_loader = IRB.conf[:USE_LOADER] if IRB.conf[:USE_LOADER]
      self.eval_history = IRB.conf[:EVAL_HISTORY] if IRB.conf[:EVAL_HISTORY]

      @ignore_sigint = IRB.conf[:IGNORE_SIGINT]
      @ignore_eof = IRB.conf[:IGNORE_EOF]

      @back_trace_limit = IRB.conf[:BACK_TRACE_LIMIT]

      self.prompt_mode = IRB.conf[:PROMPT_MODE]

      @irb_name = IRB.conf[:IRB_NAME]

      unless IRB.conf[:SINGLE_IRB] or !defined?(IRB::JobManager)
        @irb_name = @irb_name + "#" + IRB.JobManager.n_jobs.to_s
      end

      self.irb_path = "(" + @irb_name + ")"

      case input_method
      when nil
        @io = nil
        case use_multiline?
        when nil
          if term_interactive? && IRB.conf[:PROMPT_MODE] != :INF_RUBY && !use_singleline?
            # Both of multiline mode and singleline mode aren't specified.
            @io = RelineInputMethod.new(build_completor)
          else
            @io = nil
          end
        when false
          @io = nil
        when true
          @io = RelineInputMethod.new(build_completor)
        end
        unless @io
          case use_singleline?
          when nil
            if (defined?(ReadlineInputMethod) && term_interactive? &&
                IRB.conf[:PROMPT_MODE] != :INF_RUBY)
              @io = ReadlineInputMethod.new
            else
              @io = nil
            end
          when false
            @io = nil
          when true
            if defined?(ReadlineInputMethod)
              @io = ReadlineInputMethod.new
            else
              @io = nil
            end
          else
            @io = nil
          end
        end
        @io = StdioInputMethod.new unless @io

      when '-'
        @io = FileInputMethod.new($stdin)
        @irb_name = '-'
        self.irb_path = '-'
      when String
        @io = FileInputMethod.new(input_method)
        @irb_name = File.basename(input_method)
        self.irb_path = input_method
      else
        @io = input_method
      end
      @extra_doc_dirs = IRB.conf[:EXTRA_DOC_DIRS]

      @echo = IRB.conf[:ECHO]
      if @echo.nil?
        @echo = true
      end

      @echo_on_assignment = IRB.conf[:ECHO_ON_ASSIGNMENT]
      if @echo_on_assignment.nil?
        @echo_on_assignment = :truncate
      end

      @newline_before_multiline_output = IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT]
      if @newline_before_multiline_output.nil?
        @newline_before_multiline_output = true
      end

      @command_aliases = IRB.conf[:COMMAND_ALIASES].dup
    end

# File irb/ext/change-ws.rb, line 26
def change_workspace(*_main)
  if _main.empty?
    replace_workspace(home_workspace)
    return main
  end

  workspace = WorkSpace.new(_main[0])
  replace_workspace(workspace)
  workspace.load_helper_methods_to_main
end

# File irb/context.rb, line 661
def colorize_input(input, complete:)
  if IRB.conf[:USE_COLORIZE] && IRB::Color.colorable?
    lvars = local_variables || []
    if parse_command(input)
      name, sep, arg = input.split(/(\s+)/, 2)
      arg = IRB::Color.colorize_code(arg, complete: complete, local_variables: lvars)
      "#{IRB::Color.colorize(name, [:BOLD])}\e[m#{sep}#{arg}"
    else
      IRB::Color.colorize_code(input, complete: complete, local_variables: lvars)
    end
  else
    Reline::Unicode.escape_for_print(input)
  end
end

# File irb/context.rb, line 168
def eval_history=(val)
  self.class.remove_method(__method__)
  require_relative "ext/eval_history"
  __send__(__method__, val)
end

# File irb/context.rb, line 534
def file_input?
  @io.class == FileInputMethod
end

# File irb/context.rb, line 608
def from_binding?
  @irb.from_binding
end

# File irb/context.rb, line 228
def history_file
  IRB.conf[:HISTORY_FILE]
end

# File irb/context.rb, line 233
def history_file=(hist)
  IRB.conf[:HISTORY_FILE] = hist
end

# File irb/ext/change-ws.rb, line 11
def home_workspace
  if defined? @home_workspace
    @home_workspace
  else
    @home_workspace = workspace
  end
end

# File irb/context.rb, line 528
def inspect?
  @inspect_mode.nil? or @inspect_mode
end

# File irb/context.rb, line 549
def inspect_mode=(opt)

  if i = Inspector::INSPECTORS[opt]
    @inspect_mode = opt
    @inspect_method = i
    i.init
  else
    case opt
    when nil
      if Inspector.keys_with_inspector(Inspector::INSPECTORS[true]).include?(@inspect_mode)
        self.inspect_mode = false
      elsif Inspector.keys_with_inspector(Inspector::INSPECTORS[false]).include?(@inspect_mode)
        self.inspect_mode = true
      else
        puts "Can't switch inspect mode."
        return
      end
    when /^\s*\{.*\}\s*$/
      begin
        inspector = eval "proc#{opt}"
      rescue Exception
        puts "Can't switch inspect mode(#{opt})."
        return
      end
      self.inspect_mode = inspector
    when Proc
      self.inspect_mode = IRB::Inspector(opt)
    when Inspector
      prefix = "usr%d"
      i = 1
      while Inspector::INSPECTORS[format(prefix, i)]; i += 1; end
      @inspect_mode = format(prefix, i)
      @inspect_method = opt
      Inspector.def_inspector(format(prefix, i), @inspect_method)
    else
      puts "Can't switch inspect mode(#{opt})."
      return
    end
  end
  print "Switch to#{unless @inspect_mode; ' non';end} inspect mode.\n" if verbose?
  @inspect_mode
end

# File irb/context.rb, line 287
def irb_path=(path)
  @irb_path = path

  if File.exist?(path)
    @eval_path = "#{path}(#{IRB.conf[:IRB_NAME]})"
  else
    @eval_path = path
  end
end

# File irb/context.rb, line 249
def main
  workspace.main
end

# File irb/context.rb, line 636
def parse_command(code)
  command_name, arg = code.strip.split(/\s+/, 2)
  return unless code.lines.size == 1 && command_name

  arg ||= ''
  command = command_name.to_sym
  # Command aliases are always command. example: $, @
  if (alias_name = command_aliases[command])
    return [alias_name, arg]
  end

  # Assignment-like expression is not a command
  return if arg.start_with?(ASSIGN_OPERATORS_REGEXP) && !arg.start_with?(/==|=~/)

  # Local variable have precedence over command
  return if local_variables.include?(command)

  # Check visibility
  public_method = !!KERNEL_PUBLIC_METHOD.bind_call(main, command) rescue false
  private_method = !public_method && !!KERNEL_METHOD.bind_call(main, command) rescue false
  if Command.execute_as_command?(command, public_method: public_method, private_method: private_method)
    [command, arg]
  end
end

# File irb/ext/workspaces.rb, line 32
def pop_workspace
  @workspace_stack.pop if @workspace_stack.size > 1
end

# File irb/context.rb, line 512
def prompt_mode=(mode)
  @prompt_mode = mode
  pconf = IRB.conf[:PROMPT][mode]
  @prompt_i = pconf[:PROMPT_I]
  @prompt_s = pconf[:PROMPT_S]
  @prompt_c = pconf[:PROMPT_C]
  @return_format = pconf[:RETURN]
  @return_format = "%s\n" if @return_format == nil
  if ai = pconf.include?(:AUTO_INDENT)
    @auto_indent_mode = ai
  else
    @auto_indent_mode = IRB.conf[:AUTO_INDENT]
  end
end

# File irb/context.rb, line 328
def prompt_n
  warn "IRB::Context#prompt_n is deprecated and will be removed in the next major release."
  ""
end

# File irb/context.rb, line 334
def prompt_n=(_)
  warn "IRB::Context#prompt_n= is deprecated and will be removed in the next major release."
  ""
end

# File irb/context.rb, line 495
def prompting?
  verbose? || @io.prompting?
end

# File irb/ext/workspaces.rb, line 14
def push_workspace(*_main)
  if _main.empty?
    if @workspace_stack.size > 1
      # swap the top two workspaces
      previous_workspace, current_workspace = @workspace_stack.pop(2)
      @workspace_stack.push current_workspace, previous_workspace
    end
  else
    new_workspace = WorkSpace.new(workspace.binding, _main[0])
    @workspace_stack.push new_workspace
    new_workspace.load_helper_methods_to_main
  end
end

# File irb/context.rb, line 243
def replace_workspace(workspace)
  @workspace_stack.pop
  @workspace_stack.push(workspace)
end

# File irb/context.rb, line 711
def safe_method_call_on_main(method_name)
  main_object = main
  Object === main_object ? main_object.__send__(method_name) : Object.instance_method(method_name).bind_call(main_object)
end

# File irb/context.rb, line 223
def save_history
  IRB.conf[:SAVE_HISTORY]
end

# File irb/context.rb, line 219
def save_history=(val)
  IRB.conf[:SAVE_HISTORY] = val
end

# File irb/context.rb, line 504
def set_last_value(value)
  @last_value = value
  workspace.local_variable_set :_, value
end

# File irb/ext/use-loader.rb, line 37
def use_loader
  IRB.conf[:USE_LOADER]
end

# File irb/context.rb, line 174
def use_loader=(val)
  self.class.remove_method(__method__)
  require_relative "ext/use-loader"
  __send__(__method__, val)
end

# File irb/context.rb, line 163
def use_tracer=(val)
  require_relative "ext/tracer" if val
  IRB.conf[:USE_TRACER] = val
end

# File irb/context.rb, line 476
def verbose?
  if @verbose.nil?
    if @io.kind_of?(RelineInputMethod)
      false
    elsif defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)
      false
    elsif !STDIN.tty? or @io.kind_of?(FileInputMethod)
      true
    else
      false
    end
  else
    @verbose
  end
end

# File irb/context.rb, line 238
def workspace
  @workspace_stack.last
end

# File irb/context.rb, line 180
        def build_completor
  completor_type = IRB.conf[:COMPLETOR]

  # Gem repl_type_completor is added to bundled gems in Ruby 3.4.
  # Use :type as default completor only in Ruby 3.4 or later.
  verbose = !!completor_type
  completor_type ||= RUBY_VERSION >= '3.4' ? :type : :regexp

  case completor_type
  when :regexp
    return RegexpCompletor.new
  when :type
    completor = build_type_completor(verbose: verbose)
    return completor if completor
  else
    warn "Invalid value for IRB.conf[:COMPLETOR]: #{completor_type}"
  end
  # Fallback to RegexpCompletor
  RegexpCompletor.new
end

# File irb/context.rb, line 201
        def build_type_completor(verbose:)
  if RUBY_ENGINE == 'truffleruby'
    # Avoid SyntaxError. truffleruby does not support endless method definition yet.
    warn 'TypeCompletor is not supported on TruffleRuby yet' if verbose
    return
  end

  begin
    require 'repl_type_completor'
  rescue LoadError => e
    warn "TypeCompletor requires `gem repl_type_completor`: #{e.message}" if verbose
    return
  end

  ReplTypeCompletor.preload_rbs
  TypeCompletor.new(self)
end

# File irb/context.rb, line 158
        def term_interactive?
  return true if ENV['TEST_IRB_FORCE_INTERACTIVE']
  STDIN.tty? && ENV['TERM'] != 'dumb'
end