pry 0.10.2-i386-mswin32 → 1.0.0.pre1-i386-mswin32

data/lib/pry/method/weird_method_locator.rb

@@ -104,10 +104,8 @@ class Pry
           # TODO: Fix up the exception handling so we don't need a bare rescue
           if normal_method?(guess)
             return guess
-          elsif guess != guess.super
-            guess = guess.super
           else
-            break
+            guess = guess.super
           end
         end
 
@@ -166,7 +164,7 @@ class Pry
       end
 
       def valid_file?(file)
-        (File.exist?(file) && !File.directory?(file)) || Pry.eval_path == file
+        (File.exists?(file) && !File.directory?(file)) || Pry.eval_path == file
       end
 
       def lines_for_file(file)

data/lib/pry/module_candidate.rb

@@ -23,10 +23,9 @@ class Pry
       # Methods to delegate to associated `Pry::WrappedModule
       # instance`.
       private_delegates = [:lines_for_file, :method_candidates,
-                           :yard_docs?]
+                           :yard_docs?, :number_of_candidates]
 
-      public_delegates = [:wrapped, :module?, :class?, :name, :nonblank_name,
-                          :number_of_candidates]
+      public_delegates = [:wrapped, :module?, :class?, :name, :nonblank_name]
 
       def_delegators :@wrapper, *(private_delegates + public_delegates)
       private(*private_delegates)
@@ -112,13 +111,13 @@ class Pry
       # @return [Array] The source location of the base method used to
       #   calculate the source location of the candidate.
       def first_method_source_location
-        @first_method_source_location ||= method_candidates[@rank].first.source_location
+        @first_method_source_location ||= adjusted_source_location(method_candidates[@rank].first.source_location)
       end
 
       # @return [Array] The source location of the last method in this
       #   candidate's module definition.
       def last_method_source_location
-        @end_method_source_location ||= method_candidates[@rank].last.source_location
+        @end_method_source_location ||= adjusted_source_location(method_candidates[@rank].last.source_location)
       end
 
       # Return the number of lines between the start of the class definition
@@ -131,6 +130,16 @@ class Pry
 
         end_method_line - line
       end
+
+      def adjusted_source_location(sl)
+        file, line = sl
+
+        if file && RbxPath.is_core_path?(file)
+          file = RbxPath.convert_path_to_full(file)
+        end
+
+        [file, line]
+      end
     end
   end
 end

data/lib/pry/pager.rb

@@ -1,133 +1,64 @@
 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
-
-  def enabled?; !!@enabled; end
-
-  def output; @output; 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)
+  # @param [String] text
+  #   A piece of text to run through a pager.
+  # @param [Symbol?] pager
+  #   `:simple` -- Use the pure ruby pager.
+  #   `:system` -- Use the system pager (less) or the environment variable
+  #                $PAGER if set.
+  #   `nil`     -- Infer what pager to use from the environment.  What this
+  #                really means is that JRuby and systems that do not have
+  #                access to 'less' will run through the pure ruby pager.
+  def self.page(text, pager = nil)
+    case pager
+    when nil
+      no_pager = !SystemPager.available?
+      if no_pager || Pry::Helpers::BaseHelpers.jruby?
+        SimplePager.new(text).page
+      else
+        SystemPager.new(text).page
+      end
+    when :simple
+      SimplePager.new(text).page
+    when :system
+      SystemPager.new(text).page
     else
-      SystemPager.new(_pry_.output)
+      raise "'#{pager}' is not a recognized pager."
     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
+  def self.page_size
+    @page_size ||= Pry::Terminal.height!
   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
+  def initialize(text)
+    @text = text
+  end
 
-        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
+  class SimplePager < Pry::Pager
+    def page
+      # The pager size minus the number of lines used by the simple pager info bar.
+      page_size = Pry::Pager.page_size - 3
+      text_array = @text.lines.to_a
+
+      text_array.each_slice(page_size) do |chunk|
+        puts chunk.join
+        break if chunk.size < page_size
+        if text_array.size > page_size
+          puts "\n<page break> --- Press enter to continue ( q<enter> to break ) --- <page break>"
+          break if $stdin.gets.chomp == "q"
         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
+  class SystemPager < Pry::Pager
     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"
+      if pager.strip.empty? or pager =~ /^less\s*/
+        pager = "less -R -S -F -X"
       end
 
       pager
@@ -137,8 +68,7 @@ class Pry::Pager
       if @system_pager.nil?
         @system_pager = begin
           pager_executable = default_pager.split(' ').first
-          `which #{pager_executable}`
-          $?.success?
+          `which #{ pager_executable }`
         rescue
           false
         end
@@ -149,88 +79,13 @@ class Pry::Pager
 
     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
+      @pager = SystemPager.default_pager
     end
 
-    def close
-      if invoked_pager?
-        pager.close
-      else
-        @out.puts @buffer
+    def page
+      IO.popen(@pager, 'w') do |io|
+        io.write @text
       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

@@ -35,7 +35,7 @@ class Pry
       # Load the Command line options defined by this plugin (if they exist)
       def load_cli_options
         cli_options_file = File.join(spec.full_gem_path, "lib/#{spec.name}/cli.rb")
-        require cli_options_file if File.exist?(cli_options_file)
+        require cli_options_file if File.exists?(cli_options_file)
       end
       # Activate the plugin (require the gem - enables/loads the
       # plugin immediately at point of call, even if plugin is
@@ -43,7 +43,7 @@ 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('-', '_')}=", Pry::Config.from_hash({}))
+        Pry.config.send("#{gem_name.gsub('-', '_')}=", OpenStruct.new)
 
         begin
           require gem_name if !active?

data/lib/pry/pry_class.rb

@@ -1,57 +1,70 @@
+require 'ostruct'
+require 'forwardable'
 require 'pry/config'
+
 class Pry
 
-  HOME_RC_FILE = ENV["PRYRC"] || "~/.pryrc"
+  # The RC Files to load.
+  HOME_RC_FILE = "~/.pryrc"
   LOCAL_RC_FILE = "./.pryrc"
 
+  # @return [Hash] Pry's `Thread.current` hash
+  def self.current
+    Thread.current[:__pry__] ||= {}
+  end
+
+  # 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
-    attr_accessor :cli
-    attr_accessor :quiet
-    attr_accessor :last_internal_error
-    attr_accessor :config
-    attr_writer :history
 
-    def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
+    # @return [OpenStruct] Return Pry's config object.
+    attr_accessor :config
 
-    extend Pry::Config::Convenience
-    config_shortcut(*Pry::Config.shortcuts)
+    # @return [History] Return Pry's line history object.
+    attr_accessor :history
 
-    def prompt=(value)
-      config.prompt = value
-    end
+    # @return [Boolean] Whether Pry was activated from the command line.
+    attr_accessor :cli
 
-    def prompt
-      config.prompt
-    end
+    # @return [Boolean] Whether Pry sessions are quiet by default.
+    attr_accessor :quiet
 
-    def history
-      @history ||= History.new
-    end
-  end
+    # @return [Exception, nil] The last pry internal error.
+    #   (a CommandError in most cases)
+    attr_accessor :last_internal_error
 
-  #
-  # @return [main]
-  #   returns the special instance of Object, "main".
-  #
-  def self.main
-    @main ||= TOPLEVEL_BINDING.eval "self"
-  end
+    # plugin forwardables
+    def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
 
-  #
-  # @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)
+    delegate_accessors :@config, :input, :output, :commands, :prompt, :print, :exception_handler,
+      :hooks, :color, :pager, :editor, :memory_size, :extra_sticky_locals
   end
 
   # Load the given file in the context of `Pry.toplevel_binding`
-  # @param [String] file The unexpanded file path.
+  # @param [String] file_name The unexpanded file path.
   def self.load_file_at_toplevel(file)
     toplevel_binding.eval(File.read(file), file)
   rescue RescuableException => e
@@ -62,9 +75,7 @@ class Pry
   # This method can also be used to reload the files if they have changed.
   def self.load_rc_files
     rc_files_to_load.each do |file|
-      critical_section do
-        load_file_at_toplevel(file)
-      end
+      load_file_at_toplevel(file)
     end
   end
 
@@ -98,28 +109,12 @@ 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 unless initial_session?
-    @initial_session = false
+
+    return if !initial_session?
 
     # note these have to be loaded here rather than in pry_instance as
     # we only want them loaded once per entire Pry lifetime.
@@ -128,7 +123,8 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     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 Pry::Helpers::BaseHelpers.windows? && !Pry::Helpers::BaseHelpers.windows_ansi?
+
+    @initial_session = false
   end
 
   # Start a Pry REPL.
@@ -141,7 +137,6 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   #   Pry.start(Object.new, :input => MyInput.new)
   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."
@@ -150,7 +145,7 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     end
 
     options[:target] = Pry.binding_for(target || toplevel_binding)
-    options[:hooks] = Pry::Hooks.from_hash options.delete(:hooks) if options.key?(:hooks)
+
     initial_session_setup
 
     # Unless we were given a backtrace, save the current one
@@ -179,40 +174,23 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     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 [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
+  # @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
       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.
+    elsif TOPLEVEL_BINDING.eval('self') == obj
+      # special case for 'main' object :)
       obj.to_s
-    elsif Pry.config.prompt_safe_objects.any? { |v| v === obj } && obj.inspect.length <= max
+    elsif [String, Numeric, Symbol, nil, true, false].any? { |v| v === obj } && obj.inspect.length <= max_length
       obj.inspect
     else
-      id == true ? "#<#{obj.class}:0x%x>" % (obj.object_id << 1) : "#<#{obj.class}>"
+      "#<#{obj.class}>"#:%x>"# % (obj.object_id << 1)
     end
+
   rescue RescuableException
     "unknown"
   end
@@ -229,7 +207,7 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   end
 
   # Run a Pry command from outside a session. The commands available are
-  # those referenced by `Pry.config.commands` (the default command set).
+  # those referenced by `Pry.commands` (the default command set).
   # @param [String] command_string The Pry command (including arguments,
   #   if any).
   # @param [Hash] options Optional named parameters.
@@ -248,8 +226,8 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     options = {
       :target => TOPLEVEL_BINDING,
       :show_output => true,
-      :output => Pry.config.output,
-      :commands => Pry.config.commands
+      :output => Pry.output,
+      :commands => Pry.commands
     }.merge!(options)
 
     # :context for compatibility with <= 0.9.11.4
@@ -263,6 +241,7 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   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
@@ -273,22 +252,15 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   end
 
   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
+    ver = Readline::VERSION
+    if ver[/edit/i]
       warn <<-EOT
-Readline version #{Readline::VERSION} detected - will not auto_resize! correctly.
+Readline version #{ver} 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!)
@@ -303,19 +275,136 @@ Readline version #{Readline::VERSION} detected - will not auto_resize! correctly
     end
   end
 
+  def self.set_config_defaults
+    config.input = Readline
+    config.output = $stdout
+    config.commands = Pry::Commands
+    config.prompt_name = DEFAULT_PROMPT_NAME
+    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.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.output_prefix = "=> "
+
+    if defined?(Bond) && Readline::VERSION !~ /editline/i
+      config.completer = Pry::BondCompleter.start
+    else
+      config.completer = Pry::InputCompleter.start
+    end
+
+    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
+
+    config.memory_size = 100
+
+    config.extra_sticky_locals = {}
+
+    config.ls ||= OpenStruct.new({
+      :heading_color            => :bright_blue,
+
+      :public_method_color      => :default,
+      :private_method_color     => :blue,
+      :protected_method_color   => :blue,
+      :method_missing_color     => :bright_red,
+
+      :local_var_color          => :yellow,
+      :pry_var_color            => :default,         # 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
+
+      # What should separate items listed by ls? (TODO: we should allow a columnar layout)
+      :separator                => "  ",
+
+      # 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]
+    })
+  end
+
   # Set all the configurable options back to their default values
   def self.reset_defaults
+    set_config_defaults
+
     @initial_session = true
-    self.config = Pry::Config.new Pry::Config::Default.new
+
+    self.custom_completions = DEFAULT_CUSTOM_COMPLETIONS
     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
@@ -329,7 +418,7 @@ Readline version #{Readline::VERSION} detected - will not auto_resize! correctly
     if Binding === target
       target
     else
-      if Pry.main == target
+      if TOPLEVEL_BINDING.eval('self') == target
         TOPLEVEL_BINDING
       else
         target.__binding__
@@ -359,16 +448,16 @@ Readline version #{Readline::VERSION} detected - will not auto_resize! correctly
   end
 
   def self.in_critical_section?
-    Thread.current[:pry_critical_section] ||= 0
-    Thread.current[:pry_critical_section] > 0
+    @critical_section ||= 0
+    @critical_section > 0
   end
 
   def self.critical_section(&block)
-    Thread.current[:pry_critical_section] ||= 0
-    Thread.current[:pry_critical_section] += 1
+    @critical_section ||= 0
+    @critical_section += 1
     yield
   ensure
-    Thread.current[:pry_critical_section] -= 1
+    @critical_section -= 1
   end
 end