pry 0.9.4pre1-i386-mswin32 → 0.9.4pre2-i386-mswin32

data/lib/pry/helpers/text.rb

@@ -69,8 +69,9 @@ class Pry
         # @return [String]
         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
+            adjusted_index = (index + offset).to_s.rjust(max_width)
             "#{self.send(color, adjusted_index)}: #{line}"
           end.join
         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,9 +1,17 @@
 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, :spec, :active
@@ -12,22 +20,25 @@ class Pry
         @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
-          $stderr.puts "Warning: 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
@@ -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
 
@@ -129,38 +111,27 @@ 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
-    Readline::HISTORY.push(*File.readlines(history_file).map(&:chomp)) if File.exists?(history_file)
-    @loaded_history = Readline::HISTORY.to_a
+    Pry.history.load(history_file) if File.exists?(history_file)
   end
 
   # Save new lines of Readline history if required.
   def self.save_history
-    history_to_save = Readline::HISTORY.to_a
-
-    # Omit any history we read from the file.This check is needed because
-    # `hist --clear` would otherwise cause us to not save history in this
-    # session.
-    if history_to_save[0...@loaded_history.size] == @loaded_history
-      history_to_save = history_to_save[@loaded_history.size..-1]
-    end
-
-    File.open(history_file, 'a') do |f|
-      f.puts history_to_save.join("\n") if history_to_save.size > 0
-    end
-
-    # Update @loaded_history so that future calls to save_history
-    # will do the right thing.
-    @loaded_history = Readline::HISTORY.to_a
+    Pry.history.save(history_file)
   end
 
   # Get the full path of the history_path for pry.
@@ -205,9 +176,9 @@ class Pry
 
   def self.default_editor_for_platform
     if RUBY_PLATFORM =~ /mswin|mingw/
-      ENV['EDITOR'] || "notepad"
+      ENV['VISUAL'] || ENV['EDITOR'] || "notepad"
     else
-      ENV['EDITOR'] || "nano"
+      ENV['VISUAL'] || ENV['EDITOR'] || "nano"
     end
   end
 
@@ -238,6 +209,8 @@ class Pry
     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
 
@@ -249,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`

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
-
-    Pry.save_history if Pry.config.history.should_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,21 +210,15 @@ 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 }")
-
-    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)
 
-    res = set_last_result(target.eval(code, Pry.eval_path, Pry.current_line), target)
-    res
-  rescue SystemExit => e
-    exit
-  rescue Exception => 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
     update_input_history(code)
@@ -253,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
@@ -265,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.
@@ -284,13 +282,14 @@ 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.
@@ -299,12 +298,23 @@ class Pry
   # @param [String] eval_string The cumulative lines of input.
   # @param [Binding] target The target of the Pry session.
   def process_line(val, eval_string, target)
-    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
-      # only commands (with no ret_value) should have an empty `val` so this ignores their result
+      # only commands should have an empty `val`
+      # so this ignores their result
       eval_string << "#{val.rstrip}\n" if !val.empty?
     end
   end
@@ -317,8 +327,7 @@ class Pry
     @last_result_is_exception = false
     @output_array << result
 
-    Pry.last_result = result
-    target.eval("_ = ::Pry.last_result")
+    self.last_result = result
   end
 
   # Set the last exception for a session.
@@ -336,8 +345,7 @@ class Pry
     @last_result_is_exception = true
     @output_array << ex
 
-    Pry.last_exception = ex
-    target.eval("_ex_ = ::Pry.last_exception")
+    self.last_exception = ex
   end
 
   # Update Pry's internal state after evalling code.
@@ -350,28 +358,6 @@ class Pry
       Pry.line_buffer.push(*code.each_line)
       Pry.current_line += code.each_line.count
     end
-    if Readline::HISTORY.size > 0
-
-      # all this fluff is to get around annoying bug in libedit on
-      # ruby 1.8.7
-      final_index = -1
-      begin
-        Readline::HISTORY[-1]
-      rescue IndexError
-        final_index = -2
-      end
-      last = Readline::HISTORY[final_index].strip
-      prev = Readline::HISTORY.size > 1 ? Readline::HISTORY[final_index - 1].strip : ''
-      Readline::HISTORY.pop if last && (last.empty? || last == prev)
-    end
-  end
-
-  # Set the active instance for a session.
-  # 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")
   end
 
   # @return [Boolean] True if the last result is an exception that was raised,
@@ -388,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
@@ -424,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