class Pry

# File lib/pry/code.rb, line 12
def Code(obj)
  case obj
  when Code
    obj
  when ::Method, UnboundMethod, Proc, Pry::Method
    Code.from_method(obj)
  else
    Code.new(obj)
  end
end

# File lib/pry/method.rb, line 7
def Method(obj)
  if obj.is_a? Pry::Method
    obj
  else
    Pry::Method.new(obj)
  end
end

# File lib/pry/wrapped_module.rb, line 7
def WrappedModule(obj)
  if obj.is_a? Pry::WrappedModule
    obj
  else
    Pry::WrappedModule.new(obj)
  end
end

# File lib/pry/pry_class.rb, line 305
  def self.auto_resize!
    Pry.config.input # by default, load Readline

    if !defined?(Readline) || Pry.config.input != Readline
      warn "Sorry, you must be using Readline for Pry.auto_resize! to work."
      return
    end

    if Readline::VERSION =~ /edit/i
      warn <<-EOT
Readline version #{Readline::VERSION} detected - will not auto_resize! correctly.
  For the fix, use GNU Readline instead:
  https://github.com/guard/guard/wiki/Add-proper-Readline-support-to-Ruby-on-Mac-OS-X
      EOT
      return
    end

    trap :WINCH do
      begin
        Readline.set_screen_size(*Terminal.size!)
      rescue => e
        warn "\nPry.auto_resize!'s Readline.set_screen_size failed: #{e}"
      end
      begin
        Readline.refresh_line
      rescue => e
        warn "\nPry.auto_resize!'s Readline.refresh_line failed: #{e}"
      end
    end
  end

# File lib/pry/pry_class.rb, line 360
def self.binding_for(target)
  if Binding === target
    target
  else
    if Pry.main == target
      TOPLEVEL_BINDING
    else
      target.__binding__
    end
  end
end

# File lib/pry/pry_class.rb, line 56
def configure
  yield config
end

# File lib/pry/pry_class.rb, line 398
def self.critical_section
  Thread.current[:pry_critical_section] ||= 0
  Thread.current[:pry_critical_section] += 1
  yield
ensure
  Thread.current[:pry_critical_section] -= 1
end

# File lib/pry/pry_class.rb, line 73
def self.current
  Thread.current[:__pry__] ||= Pry::Config.from_hash({}, nil)
end

# File lib/pry/pry_class.rb, line 295
def self.default_editor_for_platform
  return ENV['VISUAL'] if ENV['VISUAL'] and not ENV['VISUAL'].empty?
  return ENV['EDITOR'] if ENV['EDITOR'] and not ENV['EDITOR'].empty?
  return 'notepad' if Helpers::Platform.windows?

  %w(editor nano vi).detect do |editor|
    system("which #{editor} > /dev/null 2>&1")
  end
end

# File lib/pry/pry_class.rb, line 151
def self.final_session_setup
  return if @session_finalized

  @session_finalized = true
  load_plugins if Pry.config.should_load_plugins
  load_requires if Pry.config.should_load_requires
  load_history if Pry.config.history.should_load
  load_traps if Pry.config.should_trap_interrupts
  load_win32console if Helpers::Platform.windows? && !Helpers::Platform.windows_ansi?
end

# File lib/pry/pry_class.rb, line 41
def history
  @history ||= History.new
end

# File lib/pry/pry_class.rb, line 393
def self.in_critical_section?
  Thread.current[:pry_critical_section] ||= 0
  Thread.current[:pry_critical_section] > 0
end

# File lib/pry/pry_class.rb, line 349
def self.init
  @plugin_manager ||= PluginManager.new
  reset_defaults
  locate_plugins
end

# File lib/pry/pry_class.rb, line 258
def self.initial_session?
  @initial_session
end

# File lib/pry/pry_class.rb, line 141
def self.initial_session_setup
  return unless initial_session?

  @initial_session = false

  # note these have to be loaded here rather than in pry_instance as
  # we only want them loaded once per entire Pry lifetime.
  load_rc_files
end

# File lib/pry/pry_class.rb, line 420
def self.lazy(&block)
  Pry::Config::Lazy.new(&block)
end

# File lib/pry/pry_class.rb, line 79
def self.load_file_at_toplevel(file)
  toplevel_binding.eval(File.read(file), file)
rescue RescuableException => e
  puts "Error loading #{file}: #{e}\n#{e.backtrace.first}"
end

# File lib/pry/pry_class.rb, line 208
def self.load_file_through_repl(file_name)
  require "pry/repl_file_loader"
  REPLFileLoader.new(file_name).load
end

# File lib/pry/pry_class.rb, line 252
def self.load_history
  Pry.history.load
end

# File lib/pry/pry_class.rb, line 87
def self.load_rc_files
  rc_files_to_load.each do |file|
    critical_section do
      load_file_at_toplevel(file)
    end
  end
end

# File lib/pry/pry_class.rb, line 111
def self.load_requires
  Pry.config.requires.each do |file|
    require file
  end
end

# File lib/pry/pry_class.rb, line 119
def self.load_traps
  trap('INT') { raise Interrupt }
end

# File lib/pry/pry_class.rb, line 123
  def self.load_win32console
    begin
      require 'win32console'
      # The mswin and mingw versions of pry require win32console, so this should
      # only fail on jruby (where win32console doesn't work).
      # Instead we'll recommend ansicon, which does.
    rescue LoadError
      warn <<-WARNING if Pry.config.windows_console_warning
For a better Pry experience on Windows, please use ansicon:
  https://github.com/adoxa/ansicon
If you use an alternative to ansicon and don't want to see this warning again,
you can add "Pry.config.windows_console_warning = false" to your pryrc.
      WARNING
    end
  end

# File lib/pry/pry_class.rb, line 65
def self.main
  @main ||= TOPLEVEL_BINDING.eval "self"
end

# File lib/pry/pry_instance.rb, line 70
def initialize(options = {})
  @binding_stack = []
  @indent        = Pry::Indent.new
  @command_state = {}
  @eval_string   = ""
  @backtrace     = options.delete(:backtrace) || caller
  target = options.delete(:target)
  @config = Pry::Config.new
  config.merge!(options)
  push_prompt(config.prompt)
  @input_ring = Pry::Ring.new(config.memory_size)
  @output_ring = Pry::Ring.new(config.memory_size)
  @custom_completions = config.command_completions
  set_last_result nil
  @input_ring << nil
  push_initial_binding(target)
  exec_hook(:when_started, target, options, self)
end

# File lib/pry/pry_class.rb, line 37
def prompt
  config.prompt
end

# File lib/pry/pry_class.rb, line 33
def prompt=(value)
  config.prompt = value
end

# File lib/pry/pry_class.rb, line 96
def self.rc_files_to_load
  files = []
  files << HOME_RC_FILE if Pry.config.should_load_rc
  files << LOCAL_RC_FILE if Pry.config.should_load_local_rc
  files.map { |file| real_path_to(file) }.compact.uniq
end

# File lib/pry/pry_class.rb, line 104
def self.real_path_to(file)
  Pathname.new(File.expand_path(file)).realpath.to_s
rescue Errno::ENOENT, Errno::EACCES
  nil
end

# File lib/pry/pry_class.rb, line 337
def self.reset_defaults
  @initial_session = true
  @session_finalized = nil

  self.config = Pry::Config.new Pry::Config::Default.new
  self.cli = false
  self.current_line = 1
  self.line_buffer = [""]
  self.eval_path = "(pry)"
end

# File lib/pry/pry_class.rb, line 278
def self.run_command(command_string, options = {})
  options = {
    target: TOPLEVEL_BINDING,
    show_output: true,
    output: Pry.config.output,
    commands: Pry.config.commands
  }.merge!(options)

  # :context for compatibility with <= 0.9.11.4
  target = options[:context] || options[:target]
  output = options[:show_output] ? options[:output] : StringIO.new

  pry = Pry.new(output: output, target: target, commands: options[:commands])
  pry.eval command_string
  nil
end

# File lib/pry/pry_class.rb, line 169
def self.start(target = nil, options = {})
  return if ENV['DISABLE_PRY']
  if ENV['FAIL_PRY']
    raise 'You have FAIL_PRY set to true, which results in Pry calls failing'
  end

  options = options.to_hash

  if in_critical_section?
    output.puts "ERROR: Pry started inside Pry."
    output.puts "This can happen if you have a binding.pry inside a #to_s or #inspect function."
    return
  end

  options[:target] = Pry.binding_for(target || toplevel_binding)
  initial_session_setup
  final_session_setup

  # Unless we were given a backtrace, save the current one
  if options[:backtrace].nil?
    options[:backtrace] = caller

    # If Pry was started via `binding.pry`, elide that from the backtrace
    if options[:backtrace].first =~ /pry.*core_extensions.*pry/
      options[:backtrace].shift
    end
  end

  driver = options[:driver] || Pry::REPL

  # Enter the matrix
  driver.start(options)
rescue Pry::TooSafeException
  puts "ERROR: Pry cannot work with $SAFE > 0"
  raise
end

# File lib/pry/pry_class.rb, line 372
  def self.toplevel_binding
    unless defined?(@toplevel_binding) && @toplevel_binding
      # Grab a copy of the TOPLEVEL_BINDING without any local variables.
      # This binding has a default definee of Object, and new methods are
      # private (just as in TOPLEVEL_BINDING).
      TOPLEVEL_BINDING.eval <<-RUBY
        def self.__pry__
          binding
        end
        Pry.toplevel_binding = __pry__
        class << self; undef __pry__; end
      RUBY
    end
    @toplevel_binding.eval('private')
    @toplevel_binding
  end

# File lib/pry/pry_class.rb, line 389
def self.toplevel_binding=(binding)
  @toplevel_binding = binding
end

# File lib/pry/pry_class.rb, line 232
def self.view_clip(obj, options = {})
  max = options.fetch :max_length, 60
  id = options.fetch :id, false
  if obj.kind_of?(Module) && obj.name.to_s != "" && obj.name.to_s.length <= max
    obj.name.to_s
  elsif Pry.main == obj
    # special-case to support jruby.
    # fixed as of https://github.com/jruby/jruby/commit/d365ebd309cf9df3dde28f5eb36ea97056e0c039
    # we can drop in the future.
    obj.to_s
  elsif Pry.config.prompt_safe_contexts.any? { |v| v === obj } && obj.inspect.length <= max
    obj.inspect
  else
    id == true ? "#<#{obj.class}:0x%x>" % (obj.object_id << 1) : "#<#{obj.class}>"
  end
rescue RescuableException
  "unknown"
end

# File lib/pry/pry_instance.rb, line 225
def add_sticky_local(name, &block)
  config.extra_sticky_locals[name] = block
end

# File lib/pry/pry_instance.rb, line 162
def complete(str)
  return EMPTY_COMPLETIONS unless config.completer

  Pry.critical_section do
    completer = config.completer.new(config.input, self)
    completer.call str, target: current_binding, custom_completions: custom_completions.call.push(*sticky_locals.keys)
  end
end

# File lib/pry/pry_instance.rb, line 141
def current_binding
  binding_stack.last
end

# File lib/pry/pry_instance.rb, line 267
def eval(line, options = {})
  return false if @stopped

  exit_value = nil
  exception = catch(:raise_up) do
    exit_value = catch(:breakout) do
      handle_line(line, options)
      # We use 'return !@stopped' here instead of 'return true' so that if
      # handle_line has stopped this pry instance (e.g. by opening _pry_.repl and
      # then popping all the bindings) we still exit immediately.
      return !@stopped
    end
    exception = false
  end

  @stopped = true
  @exit_value = exit_value

  # TODO: make this configurable?
  raise exception if exception

  return false
end

# File lib/pry/pry_instance.rb, line 382
def evaluate_ruby(code)
  inject_sticky_locals!
  exec_hook :before_eval, code, self

  result = current_binding.eval(code, Pry.eval_path, Pry.current_line)
  set_last_result(result, code)
ensure
  update_input_history(code)
  exec_hook :after_eval, result, self
end

# File lib/pry/pry_instance.rb, line 498
def exec_hook(name, *args, &block)
  e_before = hooks.errors.size
  hooks.exec_hook(name, *args, &block).tap do
    hooks.errors[e_before..-1].each do |e|
      output.puts "#{name} hook failed: #{e.class}: #{e.message}"
      output.puts "#{e.backtrace.first}"
      output.puts "(see _pry_.hooks.errors to debug)"
    end
  end
end

# File lib/pry/pry_instance.rb, line 186
def inject_local(name, value, b)
  value = Proc === value ? value.call : value
  if b.respond_to?(:local_variable_set)
    b.local_variable_set name, value
  else # < 2.1
    begin
      Pry.current[:pry_local] = value
      b.eval "#{name} = ::Pry.current[:pry_local]"
    ensure
      Pry.current[:pry_local] = nil
    end
  end
end

# File lib/pry/pry_instance.rb, line 214
def inject_sticky_locals!
  sticky_locals.each_pair do |name, value|
    inject_local(name, value, current_binding)
  end
end

# File lib/pry/pry_instance.rb, line 91
def input_array
  unless @input_array_warn
    loc = caller_locations(1..1).first
    warn(
      "#{loc.path}:#{loc.lineno}: warning: method #{self.class}##{__method__} " \
      "is deprecated. Use #{self.class}#input_ring instead"
    )
    @input_array_warn = true
  end

  @input_ring
end

# File lib/pry/pry_instance.rb, line 526
def last_exception=(e)
  last_exception = Pry::LastException.new(e)
  @last_result_is_exception = true
  @output_ring << last_exception
  @last_exception = last_exception
end

# File lib/pry/pry_instance.rb, line 548
def last_result_is_exception?
  @last_result_is_exception
end

# File lib/pry/pry_instance.rb, line 203
def memory_size
  @output_ring.max_size
end

# File lib/pry/pry_instance.rb, line 208
def memory_size=(size)
  @input_ring = Pry::Ring.new(size)
  @output_ring = Pry::Ring.new(size)
end

# File lib/pry/pry_instance.rb, line 644
def output
  Pry::Output.new(self)
end

# File lib/pry/pry_instance.rb, line 106
def output_array
  unless @output_array_warn
    loc = caller_locations(1..1).first
    warn(
      "#{loc.path}:#{loc.lineno}: warning: method #{self.class}##{__method__} " \
      "is deprecated. Use #{self.class}#output_ring instead"
    )
    @output_array_warn = true
  end

  @output_ring
end

# File lib/pry/pry_instance.rb, line 636
def pager
  Pry::Pager.new(self)
end

# File lib/pry/pry_instance.rb, line 628
def pop_prompt
  prompt_stack.size > 1 ? prompt_stack.pop : prompt
end

# File lib/pry/pry_instance.rb, line 433
def process_command(val)
  val = val.lstrip if /^\s\S/ !~ val
  val = val.chomp
  result = commands.process_line(val,
    target: current_binding,
    output: output,
    eval_string: @eval_string,
    pry_instance: self,
    hooks: hooks
  )

  # set a temporary (just so we can inject the value we want into eval_string)
  Pry.current[:pry_cmd_result] = result

  # note that `result` wraps the result of command processing; if a
  # command was matched and invoked then `result.command?` returns true,
  # otherwise it returns false.
  if result.command?
    if !result.void_command?
      # the command that was invoked was non-void (had a return value) and so we make
      # the value of the current expression equal to the return value
      # of the command.
      @eval_string.replace "::Pry.current[:pry_cmd_result].retval\n"
    end
    true
  else
    false
  end
end

# File lib/pry/pry_instance.rb, line 467
def process_command_safely(val)
  process_command(val)
rescue CommandError, Pry::Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
  Pry.last_internal_error = e
  output.puts "Error: #{e.message}"
  true
end

# File lib/pry/pry_instance.rb, line 121
def prompt
  prompt_stack.last
end

# File lib/pry/pry_instance.rb, line 125
def prompt=(new_prompt)
  if prompt_stack.empty?
    push_prompt new_prompt
  else
    prompt_stack[-1] = new_prompt
  end
end

# File lib/pry/pry_instance.rb, line 148
def push_binding(object)
  @stopped = false
  binding_stack << Pry.binding_for(object)
end

# File lib/pry/pry_instance.rb, line 135
def push_initial_binding(target = nil)
  push_binding(target || Pry.toplevel_binding)
end

# File lib/pry/pry_instance.rb, line 612
def push_prompt(new_prompt)
  prompt_stack.push new_prompt
end

# File lib/pry/pry_instance.rb, line 694
def quiet?
  config.quiet
end

# File lib/pry/pry_instance.rb, line 688
def raise_up(*args); raise_up_common(false, *args); end

# File lib/pry/pry_instance.rb, line 690
def raise_up!(*args); raise_up_common(true, *args); end

# File lib/pry/pry_instance.rb, line 660
def raise_up_common(force, *args)
  exception = if args == []
                last_exception || RuntimeError.new
              elsif args.length == 1 && args.first.is_a?(String)
                RuntimeError.new(args.first)
              elsif args.length > 3
                raise ArgumentError, "wrong number of arguments"
              elsif !args.first.respond_to?(:exception)
                raise TypeError, "exception class/object expected"
              elsif args.length === 1
                args.first.exception
              else
                args.first.exception(args[1])
              end

  raise TypeError, "exception object expected" unless exception.is_a? Exception

  exception.set_backtrace(args.length === 3 ? args[2] : caller(1))

  if force || binding_stack.one?
    binding_stack.clear
    throw :raise_up, exception
  else
    binding_stack.pop
    raise exception
  end
end

# File lib/pry/pry_instance.rb, line 378
def repl(target = nil)
  Pry::REPL.new(self, target: target).start
end

# File lib/pry/pry_instance.rb, line 243
def reset_eval_string
  @eval_string = ""
end

# File lib/pry/pry_instance.rb, line 480
def run_command(val)
  commands.process_line(val,
    eval_string: @eval_string,
    target: current_binding,
    pry_instance: self,
    output: output
  )
  Pry::Command::VOID_VALUE
end

# File lib/pry/pry_instance.rb, line 561
def select_prompt
  object = current_binding.eval('self')
  open_token = @indent.open_delimiters.last || @indent.stack.last

  c = Pry::Config.assign({
      object: object,
      nesting_level: binding_stack.size - 1,
      open_token: open_token,
      session_line: Pry.history.session_line_count + 1,
      history_line: Pry.history.history_line_count + 1,
      expr_number: input_ring.count,
      _pry_: self,
      binding_stack: binding_stack,
      input_ring: input_ring,
      eval_string: @eval_string,
      cont: !@eval_string.empty?
    })

  Pry.critical_section do
    # If input buffer is empty then use normal prompt
    if eval_string.empty?
      generate_prompt(Array(prompt).first, c)
    # Otherwise use the wait prompt (indicating multi-line expression)
    else
      generate_prompt(Array(prompt).last, c)
    end
  end
end

# File lib/pry/pry_instance.rb, line 513
def set_last_result(result, code = "")
  @last_result_is_exception = false
  @output_ring << result

  self.last_result = result unless code =~ /\A\s*\z/
end

# File lib/pry/pry_instance.rb, line 555
def should_print?
  !@suppress_output
end

# File lib/pry/pry_instance.rb, line 394
def show_result(result)
  if last_result_is_exception?
    exception_handler.call(output, result, self)
  elsif should_print?
    print.call(output, result, self)
  else
    # nothin'
  end
rescue RescuableException => e
  # Being uber-paranoid here, given that this exception arose because we couldn't
  # serialize something in the user's program, let's not assume we can serialize
  # the exception either.
  begin
    output.puts "(pry) output error: #{e.inspect}\n#{e.backtrace.join("\n")}"
  rescue RescuableException => e
    if last_result_is_exception?
      output.puts "(pry) output error: failed to show exception"
    else
      output.puts "(pry) output error: failed to show result"
    end
  end
ensure
  output.flush if output.respond_to?(:flush)
end

# File lib/pry/pry_instance.rb, line 229
def sticky_locals
  { _in_: input_ring,
    _out_: output_ring,
    _pry_: self,
    _ex_: last_exception && last_exception.wrapped_exception,
    _file_: last_file,
    _dir_: last_dir,
    _: proc { last_result },
    __: proc { output_ring[-2] }
  }.merge(config.extra_sticky_locals)
end

# File lib/pry/pry_instance.rb, line 536
def update_input_history(code)
  # Always push to the @input_ring as the @output_ring is always pushed to.
  @input_ring << code
  if code
    Pry.line_buffer.push(*code.each_line)
    Pry.current_line += code.lines.count
  end
end

# File lib/pry/pry_instance.rb, line 420
def ensure_correct_encoding!(val)
  if @eval_string.empty? &&
      val.respond_to?(:encoding) &&
      val.encoding != @eval_string.encoding
    @eval_string.force_encoding(val.encoding)
  end
end

# File lib/pry/pry_instance.rb, line 590
def generate_prompt(prompt_proc, conf)
  if prompt_proc.arity == 1
    prompt_proc.call(conf)
  else
    prompt_proc.call(conf.object, conf.nesting_level, conf._pry_)
  end
end

# File lib/pry/pry_instance.rb, line 291
def handle_line(line, options)
  if line.nil?
    config.control_d_handler.call(@eval_string, self)
    return
  end

  ensure_correct_encoding!(line)
  Pry.history << line unless options[:generated]

  @suppress_output = false
  inject_sticky_locals!
  begin
    if !process_command_safely(line)
      @eval_string << "#{line.chomp}\n" if !line.empty? || !@eval_string.empty?
    end
  rescue RescuableException => e
    self.last_exception = e
    result = e

    Pry.critical_section do
      show_result(result)
    end
    return
  end

  # This hook is supposed to be executed after each line of ruby code
  # has been read (regardless of whether eval_string is yet a complete expression)
  exec_hook :after_read, eval_string, self

  begin
    complete_expr = Pry::Code.complete_expression?(@eval_string)
  rescue SyntaxError => e
    output.puts "SyntaxError: #{e.message.sub(/.*syntax error, */m, '')}"
    reset_eval_string
  end

  if complete_expr
    if @eval_string =~ /;\Z/ || @eval_string.empty? || @eval_string =~ /\A *#.*\n\z/
      @suppress_output = true
    end

    # A bug in jruby makes java.lang.Exception not rescued by
    # `rescue Pry::RescuableException` clause.
    #
    # * https://github.com/pry/pry/issues/854
    # * https://jira.codehaus.org/browse/JRUBY-7100
    #
    # Until that gets fixed upstream, treat java.lang.Exception
    # as an additional exception to be rescued explicitly.
    #
    # This workaround has a side effect: java exceptions specified
    # in `Pry.config.exception_whitelist` are ignored.
    jruby_exceptions = []
    if Helpers::Platform.jruby?
      jruby_exceptions << Java::JavaLang::Exception
    end

    begin
      # Reset eval string, in case we're evaluating Ruby that does something
      # like open a nested REPL on this instance.
      eval_string = @eval_string
      reset_eval_string

      result = evaluate_ruby(eval_string)
    rescue RescuableException, *jruby_exceptions => e
      # Eliminate following warning:
      # warning: singleton on non-persistent Java type X
      # (http://wiki.jruby.org/Persistence)
      if Helpers::Platform.jruby? && e.class.respond_to?('__persistent__')
        e.class.__persistent__ = true
      end
      self.last_exception = e
      result = e
    end

    Pry.critical_section do
      show_result(result)
    end
  end

  throw(:breakout) if current_binding.nil?
end

# File lib/pry/pry_instance.rb, line 600
def prompt_stack
  @prompt_stack ||= Array.new
end