class IRB::Context

# File lib/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 lib/irb/context.rb, line 645
def colorize_input(input, complete:)
  if IRB.conf[:USE_COLORIZE] && IRB::Color.colorable?
    lvars = local_variables || []
    parsed_input = parse_input(input, false)
    if parsed_input.is_a?(Statement::Command)
      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 lib/irb/context.rb, line 163
def eval_history=(val)
  self.class.remove_method(__method__)
  require_relative "ext/eval_history"
  __send__(__method__, val)
end

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

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

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

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

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

# File lib/irb/context.rb, line 507
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 lib/irb/context.rb, line 665
def inspector_support_stream_output?
  @inspect_method.support_stream_output?
end

# File lib/irb/context.rb, line 243
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 lib/irb/context.rb, line 205
def main
  workspace.main
end

# File lib/irb/context.rb, line 596
    def parse_input(code, is_assignment_expression)
      command_name, arg = code.strip.split(/\s+/, 2)
      arg ||= ''

      # command can only be 1 line
      if code.lines.size != 1 ||
        # command name is required
        command_name.nil? ||
        # local variable have precedence over command
        local_variables.include?(command_name.to_sym) ||
        # assignment expression is not a command
        (is_assignment_expression ||
        (arg.start_with?(ASSIGN_OPERATORS_REGEXP) && !arg.start_with?(/==|=~/)))
        return Statement::Expression.new(code, is_assignment_expression)
      end

      command = command_name.to_sym

      # Check command aliases
      if aliased_name = command_aliases[command]
        if command_class = Command.load_command(aliased_name)
          command = aliased_name
        elsif HelperMethod.helper_methods[aliased_name]
          message = <<~MESSAGE
            Using command alias `#{command}` for helper method `#{aliased_name}` is not supported.
            Please check the value of `IRB.conf[:COMMAND_ALIASES]`.
          MESSAGE
          return Statement::IncorrectAlias.new(message)
        else
          message = <<~MESSAGE
            You're trying to use command alias `#{command}` for command `#{aliased_name}`, but `#{aliased_name}` does not exist.
            Please check the value of `IRB.conf[:COMMAND_ALIASES]`.
          MESSAGE
          return Statement::IncorrectAlias.new(message)
        end
      else
        command_class = Command.load_command(command)
      end

      # 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_class && Command.execute_as_command?(command, public_method: public_method, private_method: private_method)
        Statement::Command.new(code, command_class, arg)
      else
        Statement::Expression.new(code, is_assignment_expression)
      end
    end

# File lib/irb/context.rb, line 470
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 lib/irb/context.rb, line 286
def prompt_n
  warn "IRB::Context#prompt_n is deprecated and will be removed in the next major release."
  ""
end

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

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

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

# File lib/irb/context.rb, line 700
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 lib/irb/context.rb, line 179
def save_history
  IRB.conf[:SAVE_HISTORY]
end

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

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

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

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

# File lib/irb/context.rb, line 434
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 lib/irb/context.rb, line 194
def workspace
  @workspace_stack.last
end