pry 0.9.0pre3-java → 0.9.4pre2-java

data/lib/pry/helpers/text.rb

@@ -1,10 +1,10 @@
 class Pry
   module Helpers
 
-    # The methods defined on {Text} are available to custom commands via {Pry::CommandContext#text}.  
+    # The methods defined on {Text} are available to custom commands via {Pry::CommandContext#text}.
     module Text
- 
-      COLORS = 
+
+      COLORS =
       {
         "black"   => 0,
         "red"     => 1,
@@ -18,7 +18,7 @@ class Pry
       }
 
       class << self
-        
+
         COLORS.each_pair do |color, value|
           define_method color do |text|
             Pry.color ? "\033[0;#{30+value}m#{text}\033[0m" : text.to_s
@@ -31,7 +31,7 @@ class Pry
 
         alias_method :grey, :bright_black
         alias_method :gray, :bright_black
-        
+
 
         # Remove any color codes from _text_.
         #
@@ -41,11 +41,11 @@ class Pry
           text.to_s.gsub(/\e\[.*?(\d)+m/ , '')
         end
 
-        # Returns _text_ as bold text for use on a terminal.  
+        # Returns _text_ as bold text for use on a terminal.
         # _Pry.color_ must be true for this method to perform any transformations.
         #
         # @param [String, #to_s] text
-        # @return [String] _text_ 
+        # @return [String] _text_
         def bold text
           Pry.color ? "\e[1m#{text}\e[0m" : text.to_s
         end
@@ -63,15 +63,16 @@ class Pry
         end
 
         # Returns _text_ in a numbered list, beginning at _offset_.
-        # 
+        #
         # @param  [#each_line] text
         # @param  [Fixnum] offset
         # @return [String]
-        def with_line_numbers text, offset
+        def with_line_numbers(text, offset, color=:blue)
           lines = text.each_line.to_a
+          max_width = (offset + lines.count).to_s.length
           lines.each_with_index.map do |line, index|
-            adjusted_index = index + offset
-            "#{self.blue adjusted_index}: #{line}"
+            adjusted_index = (index + offset).to_s.rjust(max_width)
+            "#{self.send(color, adjusted_index)}: #{line}"
           end.join
         end
       end

data/lib/pry/history.rb

@@ -0,0 +1,61 @@
+class Pry
+  # The History class is responsible for maintaining the user's input history, both
+  # internally and within Readline::HISTORY.
+  class History
+    def initialize
+      @history = []
+      @saved_lines = 0
+    end
+
+    # Loads a file's contents into the input history.
+    # @param [String] filename
+    # @return [Integer] The number of lines loaded
+    def load(filename)
+      File.foreach(filename) do |line|
+        Readline::HISTORY << line.chomp
+        @history << line.chomp
+      end
+      @saved_lines = @history.length
+    end
+
+    # Appends input history from this session to a file.
+    # @param [String] filename
+    # @return [Integer] The number of lines saved
+    def save(filename)
+      history_to_save = @history[@saved_lines..-1]
+      File.open(filename, 'a') do |f|
+        history_to_save.each { |ln| f.puts ln }
+      end
+      @saved_lines = @history.length
+      history_to_save.length
+    end
+
+    # Adds a line to the input history, ignoring blank and duplicate lines.
+    # @param [String] line
+    # @return [String] The same line that was passed in
+    def push(line)
+      unless line.empty? || (@history.last && line.strip == @history.last.strip)
+        Readline::HISTORY << line
+        @history << line
+      end
+      line
+    end
+    alias << push
+
+    # Clears all history. Anything the user entered before this point won't be
+    # saved, but anything they put in afterwards will still be appended to the
+    # history file on exit.
+    def clear
+      Readline::HISTORY.shift until Readline::HISTORY.empty?
+      @history = []
+      @saved_lines = 0
+    end
+
+    # Returns an Array containing all stored history.
+    # @return [Array<String>] An Array containing all lines of history loaded
+    #   or entered by the user in the current session.
+    def to_a
+      @history.dup
+    end
+  end
+end

data/lib/pry/plugins.rb

@@ -1,33 +1,44 @@
 class Pry
   class PluginManager
     PRY_PLUGIN_PREFIX = /^pry-/
-    PluginNotFound = Class.new(LoadError)
 
-    MessageSink = Object.new.tap { |o| def o.method_missing(*args) end }
+    # Placeholder when no associated gem found, displays warning
+    class NoPlugin
+      def initialize(name)
+        @name = name
+      end
+
+      def method_missing(*args)
+        $stderr.puts "Warning: The plugin '#{@name}' was not found! (no gem found)"
+      end
+    end
 
     class Plugin
-      attr_accessor :name, :gem_name, :enabled, :active
+      attr_accessor :name, :gem_name, :enabled, :spec, :active
 
-      def initialize(name, gem_name, enabled)
-        @name, @gem_name, @enabled = name, gem_name, enabled
+      def initialize(name, gem_name, spec, enabled)
+        @name, @gem_name, @enabled, @spec = name, gem_name, enabled, spec
       end
 
-      # Disable a plugin.
+      # Disable a plugin. (prevents plugin from being loaded, cannot
+      # disable an already activated plugin)
       def disable!
         self.enabled = false
       end
 
-      # Enable a plugin.
+      # Enable a plugin. (does not load it immediately but puts on
+      # 'white list' to be loaded)
       def enable!
         self.enabled = true
       end
 
-      # Activate the plugin (require the gem).
+      # Activate the plugin (require the gem - enables/loads the
+      # plugin immediately at point of call, even if plugin is disabled)
       def activate!
         begin
-          require gem_name
+          require gem_name if !active?
         rescue LoadError
-          raise PluginNotFound, "The plugin '#{gem_name}' was not found!"
+          $stderr.puts "Warning: The plugin '#{gem_name}' was not found! (gem found but could not be loaded)"
         end
         self.active = true
         self.enabled = true
@@ -47,7 +58,7 @@ class Pry
       (Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')).each do |gem|
         next if gem.name !~ PRY_PLUGIN_PREFIX
         plugin_name = gem.name.split('-', 2).last
-        @plugins << Plugin.new(plugin_name, gem.name, true) if !gem_located?(gem.name)
+        @plugins << Plugin.new(plugin_name, gem.name, gem, true) if !gem_located?(gem.name)
       end
       @plugins
     end
@@ -55,7 +66,7 @@ class Pry
     # @return [Hash] A hash with all plugin names (minus the 'pry-') as
     #   keys and Plugin objects as values.
     def plugins
-      h = Pry.config.plugins.strict_loading ? {} : Hash.new { MessageSink }
+      h = Hash.new { |_, key| NoPlugin.new(key) }
       @plugins.each do |plugin|
         h[plugin.name] = plugin
       end

data/lib/pry/pry_class.rb

@@ -18,26 +18,6 @@ class Pry
       def_delegators delagatee, *names.map { |v| "#{v}=" }
     end
 
-    # Get nesting data.
-    # This method should not need to be accessed directly.
-    # @return [Array] The unparsed nesting information.
-    attr_reader :nesting
-
-    # Get last value evaluated by Pry.
-    # This method should not need to be accessed directly.
-    # @return [Object] The last result.
-    attr_accessor :last_result
-
-    # Get last exception raised.
-    # This method should not need to be accessed directly.
-    # @return [Exception] The last exception.
-    attr_accessor :last_exception
-
-    # Get the active Pry instance that manages the active Pry session.
-    # This method should not need to be accessed directly.
-    # @return [Pry] The active Pry instance.
-    attr_accessor :active_instance
-
     # 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
@@ -45,10 +25,6 @@ class Pry
     #   Pry.custom_completions = proc { Dir.entries('.') }
     attr_accessor :custom_completions
 
-    # Value returned by last executed Pry command.
-    # @return [Object] The command value
-    attr_accessor :cmd_ret_value
-
     # @return [Fixnum] The current input line.
     attr_accessor :current_line
 
@@ -62,9 +38,15 @@ class Pry
     # @return [OpenStruct] Return Pry's config object.
     attr_accessor :config
 
+    # @return [History] Return Pry's line history object.
+    attr_accessor :history
+
     # @return [Boolean] Whether Pry was activated from the command line.
     attr_accessor :cli
 
+    # @return [Fixnum] The number of active Pry sessions.
+    attr_accessor :active_sessions
+
     # plugin forwardables
     def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
 
@@ -82,6 +64,13 @@ class Pry
     end
   end
 
+  # Load any Ruby files specified with the -r flag on the command line.
+  def self.load_requires
+    Pry.config.requires.each do |file|
+      require file
+    end
+  end
+
   # Start a Pry REPL.
   # This method also loads the files specified in `Pry::RC_FILES` the
   # first time it is invoked.
@@ -97,7 +86,8 @@ class Pry
       # multiple times per each new session (i.e in debugging)
       load_rc if Pry.config.should_load_rc
       load_plugins if Pry.config.plugins.enabled
-      load_history if Pry.config.history.load
+      load_requires if Pry.config.should_load_requires
+      load_history if Pry.config.history.should_load
 
       @initial_session = false
     end
@@ -121,18 +111,32 @@ class Pry
   # @param obj The object to view.
   # @param max_size The maximum number of chars before clipping occurs.
   # @return [String] The string representation of `obj`.
-  def self.view_clip(obj, max_size=60)
-    if obj.inspect.size < max_size
+  def self.view_clip(obj, max_length = 60)
+    if obj.kind_of?(Module) && obj.name && obj.name != "" && obj.name.to_s.length <= max_length
+      obj.name.to_s
+    elsif obj.inspect.length <= max_length
       obj.inspect
-    else
+    else 
       "#<#{obj.class}:%#x>" % (obj.object_id << 1)
     end
+
+  rescue
+    "unknown"
   end
 
   # Load Readline history if required.
   def self.load_history
-    history_file = File.expand_path(Pry.config.history.file)
-    Readline::HISTORY.push(*File.readlines(history_file).map(&:chomp)) if File.exists?(history_file)
+    Pry.history.load(history_file) if File.exists?(history_file)
+  end
+
+  # Save new lines of Readline history if required.
+  def self.save_history
+    Pry.history.save(history_file)
+  end
+
+  # Get the full path of the history_path for pry.
+  def self.history_file
+    File.expand_path(Pry.config.history.file)
   end
 
   # @return [Boolean] Whether this is the first time a Pry session has
@@ -172,9 +176,9 @@ class Pry
 
   def self.default_editor_for_platform
     if RUBY_PLATFORM =~ /mswin|mingw/
-      ENV['EDITOR'] ? ENV['EDITOR'] : "notepad"
+      ENV['VISUAL'] || ENV['EDITOR'] || "notepad"
     else
-      ENV['EDITOR'] ? ENV['EDITOR'] : "nano"
+      ENV['VISUAL'] || ENV['EDITOR'] || "nano"
     end
   end
 
@@ -190,16 +194,23 @@ class Pry
     config.pager = true
     config.editor = default_editor_for_platform
     config.should_load_rc = true
+    config.disable_auto_reload = false
+    config.command_prefix = ""
 
     config.plugins ||= OpenStruct.new
     config.plugins.enabled = true
     config.plugins.strict_loading = true
 
+    config.requires ||= []
+    config.should_load_requires = true
+
     config.history ||= OpenStruct.new
-    config.history.save = true
-    config.history.load = true
+    config.history.should_save = true
+    config.history.should_load = true
     config.history.file = File.expand_path("~/.pry_history")
 
+    config.control_d_handler = DEFAULT_CONTROL_D_HANDLER
+
     config.memory_size = 100
   end
 
@@ -211,32 +222,22 @@ class Pry
 
     self.custom_completions = DEFAULT_CUSTOM_COMPLETIONS
     self.cli = false
-    self.current_line = 0
-    self.line_buffer = []
+    self.current_line = 1
+    self.line_buffer = [""]
     self.eval_path = "(pry)"
+    self.active_sessions = 0
   end
 
   # Basic initialization.
   def self.init
     @plugin_manager ||= PluginManager.new
-
     self.config ||= Config.new
+    self.history ||= History.new
+
     reset_defaults
     locate_plugins
   end
 
-  @nesting = []
-  def @nesting.level
-    last.is_a?(Array) ? last.first : nil
-  end
-
-  # Return all active Pry sessions.
-  # @return [Array<Pry>] Active Pry sessions.
-  def self.sessions
-    # last element in nesting array is the pry instance
-    nesting.map(&:last)
-  end
-
   # Return a `Binding` object for `target` or return `target` if it is
   # already a `Binding`.
   # In the case where `target` is top-level then return `TOPLEVEL_BINDING`
@@ -246,7 +247,7 @@ class Pry
     if target.is_a?(Binding)
       target
     else
-      if target == TOPLEVEL_BINDING.eval('self')
+      if TOPLEVEL_BINDING.eval('self') == target
         TOPLEVEL_BINDING
       else
         target.__binding__

data/lib/pry/pry_instance.rb

@@ -10,10 +10,15 @@ class Pry
   attr_accessor :hooks
   attr_accessor :custom_completions
 
-  # Returns the target binding for the session. Note that altering this
-  # attribute will not change the target binding.
-  # @return [Binding] The target object for the session
-  attr_accessor :session_target
+  attr_accessor :binding_stack
+
+  attr_accessor :last_result
+  attr_accessor :last_exception
+  attr_accessor :last_file
+  attr_accessor :last_dir
+
+  attr_reader :input_array
+  attr_reader :output_array
 
   # Create a new `Pry` object.
   # @param [Hash] options The optional configuration parameters.
@@ -28,6 +33,7 @@ class Pry
     refresh(options)
 
     @command_processor = CommandProcessor.new(self)
+    @binding_stack     = []
   end
 
   # Refresh the Pry instance settings from the Pry class.
@@ -73,6 +79,18 @@ class Pry
     end
   end
 
+  # Injects a local variable into the provided binding.
+  # @param [String] name The name of the local to inject.
+  # @param [Object] value The value to set the local to.
+  # @param [Binding] b The binding to set the local on.
+  # @return [Object] The value the local was set to.
+  def inject_local(name, value, b)
+    Thread.current[:__pry_local__] = value
+    b.eval("#{name} = Thread.current[:__pry_local__]")
+  ensure
+    Thread.current[:__pry_local__] = nil
+  end
+
   # @return [Integer] The maximum amount of objects remembered by the inp and
   #   out arrays. Defaults to 100.
   def memory_size
@@ -84,32 +102,6 @@ class Pry
     @output_array = Pry::HistoryArray.new(size)
   end
 
-  # Get nesting data.
-  # This method should not need to be accessed directly.
-  # @return [Array] The unparsed nesting information.
-  def nesting
-    self.class.nesting
-  end
-
-  # Set nesting data.
-  # This method should not need to be accessed directly.
-  # @param v nesting data.
-  def nesting=(v)
-    self.class.nesting = v
-  end
-
-  # @return [Boolean] Whether top-level session has ended.
-  def finished_top_level_session?
-    nesting.empty?
-  end
-
-  # Return parent of current Pry session.
-  # @return [Pry] The parent of the current Pry session.
-  def parent
-    idx = Pry.sessions.index(self)
-    Pry.sessions[idx - 1] if idx && idx > 0
-  end
-
   # Execute the hook `hook_name`, if it is defined.
   # @param [Symbol] hook_name The hook to execute
   # @param [Array] args The arguments to pass to the hook.
@@ -117,41 +109,53 @@ class Pry
     hooks[hook_name].call(*args, &block) if hooks[hook_name]
   end
 
+  # Make sure special locals exist at start of session
+  def initialize_special_locals(target)
+    inject_local("_in_", @input_array, target)
+    inject_local("_out_", @output_array, target)
+    inject_local("_pry_", self, target)
+    inject_local("_ex_", nil, target)
+    inject_local("_file_", nil, target)
+    inject_local("_dir_", nil, target)
+
+    # without this line we get 1 test failure, ask Mon_Ouie
+    set_last_result(nil, target)
+    inject_local("_", nil, target)
+  end
+  private :initialize_special_locals
+
+  def inject_special_locals(target)
+    inject_local("_in_", @input_array, target)
+    inject_local("_out_", @output_array, target)
+    inject_local("_pry_", self, target)
+    inject_local("_ex_", self.last_exception, target)
+    inject_local("_file_", self.last_file, target)
+    inject_local("_dir_", self.last_dir, target)
+    inject_local("_", self.last_result, target)
+  end
+
   # Initialize the repl session.
   # @param [Binding] target The target binding for the session.
   def repl_prologue(target)
     exec_hook :before_session, output, target
-    Pry.active_instance = self
-
-    # Make sure special locals exist
-    target.eval("inp  = ::Pry.active_instance.instance_eval { @input_array }")
-    target.eval("out = ::Pry.active_instance.instance_eval { @output_array }")
+    initialize_special_locals(target)
 
-    set_active_instance(target)
     @input_array << nil # add empty input so inp and out match
-    set_last_result(Pry.last_result, target)
 
-    self.session_target = target
+    Pry.active_sessions += 1
+    binding_stack.push target
   end
 
   # Clean-up after the repl session.
   # @param [Binding] target The target binding for the session.
   # @return [Object] The return value of the repl session (if one exists).
-  def repl_epilogue(target, nesting_level, break_data)
-    nesting.pop
+  def repl_epilogue(target, break_data)
     exec_hook :after_session, output, target
 
-    # If break_data is an array, then the last element is the return value
-    break_level, return_value = Array(break_data)
-
-    # keep throwing until we reach the desired nesting level
-    if nesting_level != break_level
-      throw :breakout, break_data
-    end
-
-    save_history if Pry.config.history.save && finished_top_level_session?
-
-    return_value
+    Pry.active_sessions -= 1
+    binding_stack.pop
+    Pry.save_history if Pry.config.history.should_save && Pry.active_sessions == 0
+    break_data
   end
 
   # Start a read-eval-print-loop.
@@ -168,18 +172,13 @@ class Pry
 
     repl_prologue(target)
 
-    # cannot rely on nesting.level as
-    # nesting.level changes with new sessions
-    nesting_level = nesting.size
-
     break_data = catch(:breakout) do
-      nesting.push [nesting.size, target_self, self]
       loop do
-        rep(target)
+        rep(binding_stack.last)
       end
     end
 
-    return_value = repl_epilogue(target, nesting_level, break_data)
+    return_value = repl_epilogue(target, break_data)
     return_value || target_self
   end
 
@@ -211,29 +210,18 @@ class Pry
       Readline.completion_proc = Pry::InputCompleter.build_completion_proc target, instance_eval(&custom_completions)
     end
 
-    # save the pry instance to active_instance
-    Pry.active_instance = self
-
-    target.eval("inp = ::Pry.active_instance.instance_eval { @input_array }")
-    target.eval("out = ::Pry.active_instance.instance_eval { @output_array }")
-
-    @last_result_is_exception = false
-    set_active_instance(target)
+    # It's not actually redundant to inject them continually as we may have
+    # moved into the scope of a new Binding (e.g the user typed `cd`)
+    inject_special_locals(target)
 
     code = r(target)
 
-    Pry.line_buffer.push(*code.each_line)
-    res = set_last_result(target.eval(code, Pry.eval_path, Pry.current_line), target)
-    res
-  rescue SystemExit => e
-    exit
-  rescue Exception => e
-    @last_result_is_exception = true
-    @output_array << e
+    result = set_last_result(target.eval(code, Pry.eval_path, Pry.current_line), target)
+    result
+  rescue RescuableException => e
     set_last_exception(e, target)
   ensure
-    @input_array << code
-    Pry.current_line += code.each_line.count if code
+    update_input_history(code)
   end
 
   # Perform a read.
@@ -258,7 +246,7 @@ class Pry
       break if valid_expression?(eval_string)
     end
 
-    @suppress_output = true if eval_string =~ /;\Z/ || null_input?(val)
+    @suppress_output = true if eval_string =~ /;\Z/ || eval_string.empty?
 
     eval_string
   end
@@ -270,14 +258,19 @@ class Pry
     else
       print.call output, result
     end
-  end
-
-  # Returns true if input is "" and a command is not returning a
-  # value.
-  # @param [String] val The input string.
-  # @return [Boolean] Whether the input is null.
-  def null_input?(val)
-    val.empty? && !Pry.cmd_ret_value
+  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 "output error: #{e.inspect}"
+    rescue RescuableException => e
+      if last_result_is_exception?
+        output.puts "output error: failed to show exception"
+      else
+        output.puts "output error: failed to show result"
+      end
+    end
   end
 
   # Read a line of input and check for ^d, also determine prompt to use.
@@ -289,28 +282,40 @@ class Pry
     current_prompt = select_prompt(eval_string.empty?, target.eval('self'))
     val = readline(current_prompt)
 
-    # exit session if we receive EOF character
+    # exit session if we receive EOF character (^D)
     if !val
-      output.puts
-      throw(:breakout, nesting.level)
+      output.puts ""
+      Pry.config.control_d_handler.call(eval_string, self)
+      ""
+    else
+      val
     end
-
-    val
   end
 
   # Process the line received.
   # This method should not need to be invoked directly.
   # @param [String] val The line to process.
   # @param [String] eval_string The cumulative lines of input.
-  # @target [Binding] target The target of the Pry session.
+  # @param [Binding] target The target of the Pry session.
   def process_line(val, eval_string, target)
-    val.rstrip!
-    Pry.cmd_ret_value = @command_processor.process_commands(val, eval_string, target)
+    result = @command_processor.process_commands(val, eval_string, target)
+
+    # set a temporary (just so we can inject the value we want into eval_string)
+    Thread.current[:__pry_cmd_result__] = result
 
-    if Pry.cmd_ret_value
-      eval_string << "Pry.cmd_ret_value\n"
+    # 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? && !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 "Thread.current[:__pry_cmd_result__].retval\n"
     else
-      eval_string << "#{val}\n" if !val.empty?
+      # only commands should have an empty `val`
+      # so this ignores their result
+      eval_string << "#{val.rstrip}\n" if !val.empty?
     end
   end
 
@@ -319,9 +324,10 @@ class Pry
   # @param [Object] result The result.
   # @param [Binding] target The binding to set `_` on.
   def set_last_result(result, target)
-    Pry.last_result = result
+    @last_result_is_exception = false
     @output_array << result
-    target.eval("_ = ::Pry.last_result")
+
+    self.last_result = result
   end
 
   # Set the last exception for a session.
@@ -329,16 +335,29 @@ class Pry
   # @param [Exception] ex The exception.
   # @param [Binding] target The binding to set `_ex_` on.
   def set_last_exception(ex, target)
-    Pry.last_exception = ex
-    target.eval("_ex_ = ::Pry.last_exception")
+    class << ex
+      attr_accessor :file, :line
+    end
+
+    ex.backtrace.first =~ /(.*):(\d+)/
+    ex.file, ex.line = $1, $2.to_i
+
+    @last_result_is_exception = true
+    @output_array << ex
+
+    self.last_exception = ex
   end
 
-  # Set the active instance for a session.
+  # Update Pry's internal state after evalling code.
   # This method should not need to be invoked directly.
-  # @param [Binding] target The binding to set `_ex_` on.
-  def set_active_instance(target)
-    Pry.active_instance = self
-    target.eval("_pry_ = ::Pry.active_instance")
+  # @param [String] code The code we just eval'd
+  def update_input_history(code)
+    # Always push to the @input_array as the @output_array is always pushed to.
+    @input_array << code
+    if code
+      Pry.line_buffer.push(*code.each_line)
+      Pry.current_line += code.each_line.count
+    end
   end
 
   # @return [Boolean] True if the last result is an exception that was raised,
@@ -355,10 +374,9 @@ class Pry
   def readline(current_prompt="> ")
 
     if input == Readline
-
-      # Readline must be treated differently
-      # as it has a second parameter.
-      input.readline(current_prompt, true)
+      line = input.readline(current_prompt, false)
+      Pry.history << line.dup if line
+      line
     else
       begin
         if input.method(:readline).arity == 1
@@ -382,14 +400,6 @@ class Pry
     !@suppress_output || last_result_is_exception?
   end
 
-  # Save readline history to a file.
-  def save_history
-    history_file = File.expand_path(Pry.config.history.file)
-    File.open(history_file, 'w') do |f|
-      f.write Readline::HISTORY.to_a.join("\n")
-    end
-  end
-
   # Returns the appropriate prompt to use.
   # This method should not need to be invoked directly.
   # @param [Boolean] first_line Whether this is the first line of input
@@ -399,9 +409,9 @@ class Pry
   def select_prompt(first_line, target_self)
 
     if first_line
-      Array(prompt).first.call(target_self, nesting.level)
+      Array(prompt).first.call(target_self, binding_stack.size - 1, self)
     else
-      Array(prompt).last.call(target_self, nesting.level)
+      Array(prompt).last.call(target_self, binding_stack.size - 1, self)
     end
   end