pry 0.10.pre.1-i386-mingw32 → 0.10.0.pre3-i386-mingw32

data/lib/pry/object_path.rb

@@ -0,0 +1,82 @@
+class Pry
+  # `ObjectPath` implements the resolution of "object paths", which are strings
+  # that are similar to filesystem paths but meant for traversing Ruby objects.
+  # Examples of valid object paths include:
+  #
+  #     x
+  #     @foo/@bar
+  #     "string"/upcase
+  #     Pry/Method
+  #
+  # Object paths are mostly relevant in the context of the `cd` command.
+  # @see https://github.com/pry/pry/wiki/State-navigation
+  class ObjectPath
+    SPECIAL_TERMS = ["", "::", ".", ".."]
+
+    # @param [String] path_string The object path expressed as a string.
+    # @param [Array<Binding>] current_stack The current state of the binding
+    #   stack.
+    def initialize(path_string, current_stack)
+      @path_string   = path_string
+      @current_stack = current_stack
+    end
+
+    # @return [Array<Binding>] a new stack resulting from applying the given
+    #   path to the current stack.
+    def resolve
+      scanner = StringScanner.new(@path_string.strip)
+      stack   = @current_stack.dup
+
+      begin
+        next_segment  = ""
+
+        loop do
+          # Scan for as long as we don't see a slash
+          next_segment << scanner.scan(/[^\/]*/)
+
+          if complete?(next_segment) || scanner.eos?
+            scanner.getch # consume the slash
+            break
+          else
+            next_segment << scanner.getch # append the slash
+          end
+        end
+
+        case next_segment.chomp
+        when ""
+          stack = [stack.first]
+        when "::"
+          stack.push(TOPLEVEL_BINDING)
+        when "."
+          next
+        when ".."
+          stack.pop unless stack.size == 1
+        else
+          stack.push(Pry.binding_for(stack.last.eval(next_segment)))
+        end
+      rescue RescuableException => e
+        return handle_failure(next_segment, e)
+      end until scanner.eos?
+
+      stack
+    end
+
+    private
+
+    def complete?(segment)
+      SPECIAL_TERMS.include?(segment) || Pry::Code.complete_expression?(segment)
+    end
+
+    def handle_failure(context, err)
+      msg = [
+        "Bad object path: #{@path_string.inspect}",
+        "Failed trying to resolve: #{context.inspect}",
+        "Exception: #{err.inspect}"
+      ].join("\n")
+
+      raise CommandError.new(msg).tap { |e|
+        e.set_backtrace err.backtrace
+      }
+    end
+  end
+end

data/lib/pry/output.rb

@@ -0,0 +1,50 @@
+class Pry
+  class Output
+    attr_reader :_pry_
+
+    def initialize(_pry_)
+      @_pry_ = _pry_
+    end
+
+    def puts(*objs)
+      return print "\n" if objs.empty?
+
+      objs.each do |obj|
+        if ary = Array.try_convert(obj)
+          puts(*ary)
+        else
+          print "#{obj.to_s.chomp}\n"
+        end
+      end
+
+      nil
+    end
+
+    def print(*objs)
+      objs.each do |obj|
+        _pry_.config.output.print decolorize_maybe(obj.to_s)
+      end
+
+      nil
+    end
+    alias << print
+    alias write print
+
+    # If _pry_.config.color is currently false, removes ansi escapes from the string.
+    def decolorize_maybe(str)
+      if _pry_.config.color
+        str
+      else
+        Helpers::Text.strip_color str
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      _pry_.config.output.send(name, *args, &block)
+    end
+
+    def respond_to_missing?(*a)
+      _pry_.config.respond_to?(*a)
+    end
+  end
+end

data/lib/pry/pager.rb

@@ -0,0 +1,234 @@
+require 'pry/terminal'
+
+# A pager is an `IO`-like object that accepts text and either prints it
+# immediately, prints it one page at a time, or streams it to an external
+# program to print one page at a time.
+class Pry::Pager
+  class StopPaging < StandardError
+  end
+
+  attr_reader :_pry_
+
+  def initialize(_pry_)
+    @_pry_ = _pry_
+  end
+
+  # Send the given text through the best available pager (if `Pry.config.pager` is
+  # enabled).
+  # If you want to send text through in chunks as you generate it, use `open` to
+  # get a writable object instead.
+  # @param [String] text A piece of text to run through a pager.
+  # @param [IO] output (`$stdout`) An object to send output to.
+  def page(text)
+    open do |pager|
+      pager << text
+    end
+  end
+
+  # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`).  All
+  # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`.
+  # @param [IO] output (`$stdout`) An object to send output to.
+  def open
+    pager = best_available
+    yield pager
+  rescue StopPaging
+  ensure
+    pager.close if pager
+  end
+
+  private
+
+  attr_reader :output
+  def enabled?; !!@enabled; end
+
+  # Return an instance of the "best" available pager class -- `SystemPager` if
+  # possible, `SimplePager` if `SystemPager` isn't available, and `NullPager`
+  # if the user has disabled paging. All pagers accept output with `#puts`,
+  # `#print`, `#write`, and `#<<`. You must call `#close` when you're done
+  # writing output to a pager, and you must rescue `Pry::Pager::StopPaging`.
+  # These requirements can be avoided by using `.open` instead.
+  # @param [#<<] output ($stdout) An object to send output to.
+  def best_available
+    if !_pry_.config.pager
+      NullPager.new(_pry_.output)
+    elsif !SystemPager.available? || Pry::Helpers::BaseHelpers.jruby?
+      SimplePager.new(_pry_.output)
+    else
+      SystemPager.new(_pry_.output)
+    end
+  end
+
+  # `NullPager` is a "pager" that actually just prints all output as it comes
+  # in. Used when `Pry.config.pager` is false.
+  class NullPager
+    def initialize(out)
+      @out = out
+    end
+
+    def puts(str)
+      print "#{str.chomp}\n"
+    end
+
+    def print(str)
+      write str
+    end
+    alias << print
+
+    def write(str)
+      @out.write str
+    end
+
+    def close
+    end
+
+    private
+
+    def height
+      @height ||= Pry::Terminal.height!
+    end
+
+    def width
+      @width ||= Pry::Terminal.width!
+    end
+  end
+
+  # `SimplePager` is a straightforward pure-Ruby pager. We use it on JRuby and
+  # when we can't find a usable external pager.
+  class SimplePager < NullPager
+    def initialize(*)
+      super
+      @tracker = PageTracker.new(height - 3, width)
+    end
+
+    def write(str)
+      str.lines.each do |line|
+        @out.print line
+        @tracker.record line
+
+        if @tracker.page?
+          @out.print "\n"
+          @out.print "\e[0m"
+          @out.print "<page break> --- Press enter to continue " \
+                     "( q<enter> to break ) --- <page break>\n"
+          raise StopPaging if Readline.readline("").chomp == "q"
+          @tracker.reset
+        end
+      end
+    end
+  end
+
+  # `SystemPager` buffers output until we're pretty sure it's at least a page
+  # long, then invokes an external pager and starts streaming output to it. If
+  # `#close` is called before then, it just prints out the buffered content.
+  class SystemPager < NullPager
+    def self.default_pager
+      pager = ENV["PAGER"] || ""
+
+      # Default to less, and make sure less is being passed the correct options
+      if pager.strip.empty? or pager =~ /^less\b/
+        pager = "less -R -F -X"
+      end
+
+      pager
+    end
+
+    def self.available?
+      if @system_pager.nil?
+        @system_pager = begin
+          pager_executable = default_pager.split(' ').first
+          `which #{ pager_executable }`
+        rescue
+          false
+        end
+      else
+        @system_pager
+      end
+    end
+
+    def initialize(*)
+      super
+      @tracker = PageTracker.new(height, width)
+      @buffer  = ""
+    end
+
+    def write(str)
+      if invoked_pager?
+        write_to_pager str
+      else
+        @tracker.record str
+        @buffer << str
+
+        if @tracker.page?
+          write_to_pager @buffer
+        end
+      end
+    rescue Errno::EPIPE
+      raise StopPaging
+    end
+
+    def close
+      if invoked_pager?
+        pager.close
+      else
+        @out.puts @buffer
+      end
+    end
+
+    private
+
+    def write_to_pager(text)
+      pager.write @out.decolorize_maybe(text)
+    end
+
+    def invoked_pager?
+      @pager
+    end
+
+    def pager
+      @pager ||= IO.popen(self.class.default_pager, 'w')
+    end
+  end
+
+  # `PageTracker` tracks output to determine whether it's likely to take up a
+  # whole page. This doesn't need to be super precise, but we can use it for
+  # `SimplePager` and to avoid invoking the system pager unnecessarily.
+  #
+  # One simplifying assumption is that we don't need `#page?` to return `true`
+  # on the basis of an incomplete line. Long lines should be counted as
+  # multiple lines, but we don't have to transition from `false` to `true`
+  # until we see a newline.
+  class PageTracker
+    def initialize(rows, cols)
+      @rows, @cols = rows, cols
+      reset
+    end
+
+    def record(str)
+      str.lines.each do |line|
+        if line.end_with? "\n"
+          @row += ((@col + line_length(line) - 1) / @cols) + 1
+          @col  = 0
+        else
+          @col += line_length(line)
+        end
+      end
+    end
+
+    def page?
+      @row >= @rows
+    end
+
+    def reset
+      @row = 0
+      @col = 0
+    end
+
+    private
+
+    # Approximation of the printable length of a given line, without the
+    # newline and without ANSI color codes.
+    def line_length(line)
+      line.chomp.gsub(/\e\[[\d;]*m/, '').length
+    end
+  end
+end

data/lib/pry/plugins.rb

@@ -43,13 +43,15 @@ class Pry
       # Does not reload plugin if it's already active.
       def activate!
         # Create the configuration object for the plugin.
-        Pry.config.send("#{gem_name.gsub('-', '_')}=", OpenStruct.new)
+        Pry.config.send("#{gem_name.gsub('-', '_')}=", Pry::Config.from_hash({}))
 
         begin
           require gem_name if !active?
         rescue LoadError => e
-          warn "Warning: The plugin '#{gem_name}' was not found! (gem found but could not be loaded)"
+          warn "Found plugin #{gem_name}, but could not require '#{gem_name}'"
           warn e
+        rescue => e
+          warn "require '#{gem_name}' # Failed, saying: #{e}"
         end
 
         self.active = true
@@ -99,4 +101,3 @@ class Pry
   end
 
 end
-

data/lib/pry/prompt.rb

@@ -0,0 +1,26 @@
+class Pry::Prompt
+  MAP = {
+    "default" => {
+      value: Pry::DEFAULT_PROMPT,
+      description: "The default Pry prompt. Includes information about the\n" \
+                   "current expression number, evaluation context, and nesting\n" \
+                   "level, plus a reminder that you're using Pry."
+    },
+
+    "simple" => {
+      value: Pry::SIMPLE_PROMPT,
+      description: "A simple '>>'."
+    },
+
+    "nav" => {
+      value: Pry::NAV_PROMPT,
+      description: "A prompt that displays the binding stack as a path and\n" \
+                   "includes information about _in_ and _out_."
+    },
+
+    "none" => {
+      value: Pry::NO_PROMPT,
+      description: "Wave goodbye to the Pry prompt."
+    }
+ }
+end

data/lib/pry/pry_class.rb

@@ -1,85 +1,88 @@
-require 'ostruct'
-require 'forwardable'
 require 'pry/config'
-
 class Pry
 
-  # The RC Files to load.
-  RC_FILES = ["~/.pryrc"]
+  HOME_RC_FILE = ENV["PRYRC"] || "~/.pryrc"
   LOCAL_RC_FILE = "./.pryrc"
 
-  # class accessors
   class << self
     extend Forwardable
-
-    # convenience method
-    def self.delegate_accessors(delagatee, *names)
-      def_delegators delagatee, *names
-      def_delegators delagatee, *names.map { |v| "#{v}=" }
-    end
-
-    # Get/Set the Proc that defines extra Readline completions (on top
-    # of the ones defined for IRB).
-    # @return [Proc] The Proc that defines extra Readline completions (on top
-    # @example Add file names to completion list
-    #   Pry.custom_completions = proc { Dir.entries('.') }
     attr_accessor :custom_completions
-
-    # @return [Fixnum] The current input line.
     attr_accessor :current_line
-
-    # @return [Array] The Array of evaluated expressions.
     attr_accessor :line_buffer
-
-    # @return [String] The __FILE__ for the `eval()`. Should be "(pry)"
-    #   by default.
     attr_accessor :eval_path
-
-    # @return [OpenStruct] Return Pry's config object.
+    attr_accessor :cli
+    attr_accessor :quiet
+    attr_accessor :last_internal_error
     attr_accessor :config
+    attr_writer :history
 
-    # @return [History] Return Pry's line history object.
-    attr_accessor :history
+    def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
 
-    # @return [Boolean] Whether Pry was activated from the command line.
-    attr_accessor :cli
+    extend Pry::Config::Convenience
+    config_shortcut *Pry::Config.shortcuts
 
-    # @return [Boolean] Whether Pry sessions are quiet by default.
-    attr_accessor :quiet
+    def prompt=(value)
+      config.prompt = value
+    end
 
-    # @return [Binding] A top level binding with no local variables
-    attr_accessor :toplevel_binding
+    def prompt
+      config.prompt
+    end
 
-    # plugin forwardables
-    def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
+    def history
+      @history ||= History.new
+    end
+  end
 
-    delegate_accessors :@config, :input, :output, :commands, :prompt, :print, :exception_handler,
-      :hooks, :color, :pager, :editor, :memory_size, :input_stack, :extra_sticky_locals
+  #
+  # @return [main]
+  #   returns the special instance of Object, "main".
+  #
+  def self.main
+    @main ||= TOPLEVEL_BINDING.eval "self"
   end
 
+  #
+  # @return [Pry::Config]
+  #  Returns a value store for an instance of Pry running on the current thread.
+  #
+  def self.current
+    Thread.current[:__pry__] ||= Pry::Config.from_hash({}, nil)
+  end
 
   # Load the given file in the context of `Pry.toplevel_binding`
-  # @param [String] file_name The unexpanded file path.
-  def self.load_file_at_toplevel(file_name)
-    full_name = File.expand_path(file_name)
-    begin
-      toplevel_binding.eval(File.read(full_name)) if File.exists?(full_name)
-    rescue RescuableException => e
-      puts "Error loading #{file_name}: #{e}"
-    end
+  # @param [String] file The unexpanded file path.
+  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
 
-  # Load the rc files given in the `Pry::RC_FILES` array.
+  # Load HOME_RC_FILE and LOCAL_RC_FILE if appropriate
   # This method can also be used to reload the files if they have changed.
-  def self.load_rc
-    RC_FILES.uniq.each do |file_name|
-      load_file_at_toplevel(file_name)
+  def self.load_rc_files
+    rc_files_to_load.each do |file|
+      critical_section do
+        load_file_at_toplevel(file)
+      end
     end
   end
 
   # Load the local RC file (./.pryrc)
-  def self.load_local_rc
-    load_file_at_toplevel(LOCAL_RC_FILE)
+  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
+
+  # Expand a file to its canonical name (following symlinks as appropriate)
+  def self.real_path_to(file)
+    expanded = Pathname.new(File.expand_path(file)).realpath.to_s
+    # For rbx 1.9 mode [see rubinius issue #2165]
+    File.exist?(expanded) ? expanded : nil
+  rescue Errno::ENOENT
+    nil
   end
 
   # Load any Ruby files specified with the -r flag on the command line.
@@ -95,68 +98,78 @@ class Pry
     trap('INT'){ raise Interrupt }
   end
 
+  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
+
   # Do basic setup for initial session.
   # Including: loading .pryrc, loading plugins, loading requires, and
   # loading history.
   def self.initial_session_setup
-
-    return if !initial_session?
+    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 if Pry.config.should_load_rc
-    load_local_rc if Pry.config.should_load_local_rc
+    load_rc_files
     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
-
-    @initial_session = false
+    load_win32console if Pry::Helpers::BaseHelpers.windows? && !Pry::Helpers::BaseHelpers.windows_ansi?
   end
 
   # Start a Pry REPL.
-  # This method also loads the files specified in `Pry::RC_FILES` the
+  # This method also loads `~/.pryrc` and `./.pryrc` as necessary the
   # first time it is invoked.
   # @param [Object, Binding] target The receiver of the Pry session
   # @param [Hash] options
   # @option options (see Pry#initialize)
   # @example
   #   Pry.start(Object.new, :input => MyInput.new)
-  def self.start(target=toplevel_binding, options={})
-    target = Pry.binding_for(target)
-    initial_session_setup
-
-    # create the Pry instance to manage the session
-    pry_instance = new(options)
-
-    # save backtrace
-    pry_instance.backtrace = caller
+  def self.start(target=nil, options={})
+    return if ENV['DISABLE_PRY']
+    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
 
-    # if Pry was started via binding.pry, elide that from the backtrace.
-    pry_instance.backtrace.shift if pry_instance.backtrace.first =~ /pry.*core_extensions.*pry/
+    options[:target] = Pry.binding_for(target || toplevel_binding)
+    options[:hooks] = Pry::Hooks.from_hash options.delete(:hooks) if options.key?(:hooks)
+    initial_session_setup
 
-    # yield the binding_stack to the hook for modification
-    pry_instance.exec_hook(
-                           :when_started,
-                           target,
-                           options,
-                           pry_instance
-                           )
+    # Unless we were given a backtrace, save the current one
+    if options[:backtrace].nil?
+      options[:backtrace] = caller
 
-    if !pry_instance.binding_stack.empty?
-      head = pry_instance.binding_stack.pop
-    else
-      head = target
+      # 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
 
-    # Clear the line before starting Pry. This fixes the issue discussed here:
-    # https://github.com/pry/pry/issues/566
-    if Pry.config.auto_indent
-      Kernel.print Pry::Helpers::BaseHelpers.windows_ansi? ? "\e[0F" : "\e[0G"
-    end
+    driver = options[:driver] || Pry::REPL
 
     # Enter the matrix
-    pry_instance.repl(head)
+    driver.start(options)
+  rescue Pry::TooSafeException
+    puts "ERROR: Pry cannot work with $SAFE > 0"
+    raise
   end
 
   # Execute the file through the REPL loop, non-interactively.
@@ -166,23 +179,40 @@ class Pry
     REPLFileLoader.new(file_name).load
   end
 
+  #
   # An inspector that clips the output to `max_length` chars.
   # In case of > `max_length` chars the `#<Object...> notation is used.
-  # @param obj The object to view.
-  # @param max_length The maximum number of chars before clipping occurs.
-  # @return [String] The string representation of `obj`.
-  def self.view_clip(obj, max_length = 60)
-    if obj.kind_of?(Module) && obj.name.to_s != "" && obj.name.to_s.length <= max_length
+  #
+  # @param [Object] obj
+  #   The object to view.
+  #
+  # @param [Hash] options
+  # @option options [Integer] :max_length (60)
+  #   The maximum number of chars before clipping occurs.
+  #
+  # @option options [Boolean] :id (false)
+  #   Boolean to indicate whether or not a hex reprsentation of the object ID
+  #   is attached to the return value when the length of inspect is greater than
+  #   value of `:max_length`.
+  #
+  # @return [String]
+  #   The string representation of `obj`.
+  #
+  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 TOPLEVEL_BINDING.eval('self') == obj
-      # special case for 'main' object :)
+    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 [String, Numeric, Symbol, nil, true, false].any? { |v| v === obj } && obj.inspect.length <= max_length
+    elsif Pry.config.prompt_safe_objects.any? { |v| v === obj } && obj.inspect.length <= max
       obj.inspect
     else
-      "#<#{obj.class}>"#:%x>"# % (obj.object_id << 1)
+      id == true ? "#<#{obj.class}:0x%x>" % (obj.object_id << 1) : "#<#{obj.class}>"
     end
-
   rescue RescuableException
     "unknown"
   end
@@ -192,11 +222,6 @@ class Pry
     Pry.history.load
   end
 
-  # Save new lines of Readline history if required.
-  def self.save_history
-    Pry.history.save
-  end
-
   # @return [Boolean] Whether this is the first time a Pry session has
   #   been started since loading the Pry class.
   def self.initial_session?
@@ -204,38 +229,40 @@ class Pry
   end
 
   # Run a Pry command from outside a session. The commands available are
-  # those referenced by `Pry.commands` (the default command set).
+  # those referenced by `Pry.config.commands` (the default command set).
   # @param [String] command_string The Pry command (including arguments,
   #   if any).
   # @param [Hash] options Optional named parameters.
   # @return [Object] The return value of the Pry command.
-  # @option options [Object, Binding] :context The object context to run the
+  # @option options [Object, Binding] :target The object to run the
   #   command under. Defaults to `TOPLEVEL_BINDING` (main).
   # @option options [Boolean] :show_output Whether to show command
   #   output. Defaults to true.
   # @example Run at top-level with no output.
   #   Pry.run_command "ls"
   # @example Run under Pry class, returning only public methods.
-  #   Pry.run_command "ls -m", :context => Pry
+  #   Pry.run_command "ls -m", :target => Pry
   # @example Display command output.
   #   Pry.run_command "ls -av", :show_output => true
   def self.run_command(command_string, options={})
     options = {
-      :context => TOPLEVEL_BINDING,
+      :target => TOPLEVEL_BINDING,
       :show_output => true,
-      :output => Pry.output,
-      :commands => Pry.commands
+      :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.new(:output => output, :input => StringIO.new(command_string), :commands => options[:commands], :prompt => proc {""}, :hooks => Pry::Hooks.new).rep(options[:context])
+    pry = Pry.new(:output   => output, :target   => target, :commands => options[:commands])
+    pry.eval command_string
   end
 
   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?
-
     if Helpers::BaseHelpers.windows?
       'notepad'
     else
@@ -245,129 +272,50 @@ class Pry
     end
   end
 
-  def self.set_config_defaults
-    config.input = Readline
-    config.output = $stdout
-    config.commands = Pry::Commands
-    config.prompt = DEFAULT_PROMPT
-    config.print = DEFAULT_PRINT
-    config.exception_handler = DEFAULT_EXCEPTION_HANDLER
-    config.exception_whitelist = DEFAULT_EXCEPTION_WHITELIST
-    config.default_window_size = 5
-    config.hooks = DEFAULT_HOOKS
-    config.input_stack = []
-    config.color = Helpers::BaseHelpers.use_ansi_codes?
-    config.pager = true
-    config.system = DEFAULT_SYSTEM
-    config.editor = default_editor_for_platform
-    config.should_load_rc = true
-    config.should_load_local_rc = true
-    config.should_trap_interrupts = Helpers::BaseHelpers.jruby?
-    config.disable_auto_reload = false
-    config.command_prefix = ""
-    config.auto_indent = Helpers::BaseHelpers.use_ansi_codes?
-    config.correct_indent = true
-    config.collision_warning = false
-
-    config.gist ||= OpenStruct.new
-    config.gist.inspecter = proc(&:pretty_inspect)
-
-    config.should_load_plugins = true
-
-    config.requires ||= []
-    config.should_load_requires = true
-
-    config.history ||= OpenStruct.new
-    config.history.should_save = true
-    config.history.should_load = true
-    config.history.file = File.expand_path("~/.pry_history") rescue nil
-
-    if config.history.file.nil?
-      config.should_load_rc = false
-      config.history.should_save = false
-      config.history.should_load = false
-    end
-
-    config.control_d_handler = DEFAULT_CONTROL_D_HANDLER
+  def self.auto_resize!
+    Pry.config.input # by default, load Readline
 
-    config.memory_size = 100
-
-    config.extra_sticky_locals = {}
-
-    config.ls ||= OpenStruct.new({
-      :heading_color            => :default,
-
-      :public_method_color      => :default,
-      :private_method_color     => :green,
-      :protected_method_color   => :yellow,
-      :method_missing_color     => :bright_red,
-
-      :local_var_color          => :default,
-      :pry_var_color            => :red,         # e.g. _, _pry_, _file_
-
-      :instance_var_color       => :blue,        # e.g. @foo
-      :class_var_color          => :bright_blue, # e.g. @@foo
-
-      :global_var_color         => :default,     # e.g. $CODERAY_DEBUG, $eventmachine_library
-      :builtin_global_color     => :cyan,        # e.g. $stdin, $-w, $PID
-      :pseudo_global_color      => :cyan,        # e.g. $~, $1..$9, $LAST_MATCH_INFO
-
-      :constant_color           => :default,     # e.g. VERSION, ARGF
-      :class_constant_color     => :blue,        # e.g. Object, Kernel
-      :exception_constant_color => :magenta,     # e.g. Exception, RuntimeError
-      :unloaded_constant_color  => :yellow,      # Any constant that is still in .autoload? state
+    if !defined?(Readline) || Pry.config.input != Readline
+      warn "Sorry, you must be using Readline for Pry.auto_resize! to work."
+      return
+    end
 
-      # What should separate items listed by ls? (TODO: we should allow a columnar layout)
-      :separator                => "  ",
+    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
 
-      # Any methods defined on these classes, or modules included into these classes, will not
-      # be shown by ls unless the -v flag is used.
-      # A user of Rails may wih to add ActiveRecord::Base to the list.
-      # add the following to your .pryrc:
-      # Pry.config.ls.ceiling << ActiveRecord::Base if defined? ActiveRecordBase
-      :ceiling                  => [Object, Module, Class]
-    })
+    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
 
   # Set all the configurable options back to their default values
   def self.reset_defaults
-    set_config_defaults
-
     @initial_session = true
-
-    self.custom_completions = DEFAULT_CUSTOM_COMPLETIONS
+    self.config = Pry::Config.new Pry::Config::Default.new
     self.cli = false
     self.current_line = 1
     self.line_buffer = [""]
     self.eval_path = "(pry)"
-
-    fix_coderay_colors
-  end
-
-  # To avoid mass-confusion, we change the default colour of "white" to
-  # "blue" enabling global legibility
-  def self.fix_coderay_colors
-      to_fix = if (CodeRay::Encoders::Terminal::TOKEN_COLORS rescue nil)
-                 # CodeRay 1.0.0
-                 CodeRay::Encoders::Terminal::TOKEN_COLORS
-               else
-                 # CodeRay 0.9
-                 begin
-                   require 'coderay/encoders/term'
-                   CodeRay::Encoders::Term::TOKEN_COLORS
-                 rescue
-                 end
-               end
-
-      to_fix[:comment] = "0;34" if to_fix
   end
 
   # Basic initialization.
   def self.init
     @plugin_manager ||= PluginManager.new
-    self.config ||= Config.new
-    self.history ||= History.new
-
     reset_defaults
     locate_plugins
   end
@@ -381,23 +329,47 @@ class Pry
     if Binding === target
       target
     else
-      if TOPLEVEL_BINDING.eval('self') == target
+      if Pry.main == target
         TOPLEVEL_BINDING
       else
         target.__binding__
       end
     end
   end
-end
 
-# 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).
-def self.__binding_impl__
-  binding
+  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
+
+  def self.toplevel_binding=(binding)
+    @toplevel_binding = binding
+  end
+
+  def self.in_critical_section?
+    Thread.current[:pry_critical_section] ||= 0
+    Thread.current[:pry_critical_section] > 0
+  end
+
+  def self.critical_section(&block)
+    Thread.current[:pry_critical_section] ||= 0
+    Thread.current[:pry_critical_section] += 1
+    yield
+  ensure
+    Thread.current[:pry_critical_section] -= 1
+  end
 end
-Pry.toplevel_binding = __binding_impl__
-Pry.toplevel_binding.eval("private")
-class << self; undef __binding_impl__; end
 
 Pry.init