pry 0.9.9.6pre2-i386-mswin32 → 0.9.10-i386-mswin32

data/lib/pry/pry_class.rb

@@ -5,7 +5,8 @@ require 'pry/config'
 class Pry
 
   # The RC Files to load.
-  RC_FILES = ["~/.pryrc", "./.pryrc"]
+  RC_FILES = ["~/.pryrc"]
+  LOCAL_RC_FILE = "./.pryrc"
 
   # class accessors
   class << self
@@ -43,12 +44,12 @@ class Pry
     # @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
-
     # @return [Boolean] Whether Pry sessions are quiet by default.
     attr_accessor :quiet
 
+    # @return [Binding] A top level binding with no local variables
+    attr_accessor :toplevel_binding
+
     # plugin forwardables
     def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
 
@@ -56,19 +57,31 @@ class Pry
       :hooks, :color, :pager, :editor, :memory_size, :input_stack, :extra_sticky_locals
   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
+  end
+
   # Load the rc files given in the `Pry::RC_FILES` array.
   # This method can also be used to reload the files if they have changed.
   def self.load_rc
-    files = RC_FILES.collect { |file_name| File.expand_path(file_name) }.uniq
-    files.each do |file_name|
-      begin
-        load(file_name) if File.exists?(file_name)
-      rescue RescuableException => e
-        puts "Error loading #{file_name}: #{e}"
-      end
+    RC_FILES.uniq.each do |file_name|
+      load_file_at_toplevel(file_name)
     end
   end
 
+  # Load the local RC file (./.pryrc)
+  def self.load_local_rc
+    load_file_at_toplevel(LOCAL_RC_FILE)
+  end
+
   # Load any Ruby files specified with the -r flag on the command line.
   def self.load_requires
     Pry.config.requires.each do |file|
@@ -92,6 +105,7 @@ class Pry
     # 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_plugins if Pry.config.should_load_plugins
     load_requires if Pry.config.should_load_requires
     load_history if Pry.config.history.should_load
@@ -108,7 +122,7 @@ class Pry
   # @option options (see Pry#initialize)
   # @example
   #   Pry.start(Object.new, :input => MyInput.new)
-  def self.start(target=TOPLEVEL_BINDING, options={})
+  def self.start(target=toplevel_binding, options={})
     target = Pry.binding_for(target)
     initial_session_setup
 
@@ -122,12 +136,7 @@ class Pry
     pry_instance.backtrace.shift if pry_instance.backtrace.first =~ /pry.*core_extensions.*pry/
 
     # yield the binding_stack to the hook for modification
-    pry_instance.exec_hook(
-                           :when_started,
-                           target,
-                           options,
-                           pry_instance
-                           )
+    pry_instance.exec_hook(:when_started, target, options, pry_instance)
 
     if !pry_instance.binding_stack.empty?
       head = pry_instance.binding_stack.pop
@@ -135,10 +144,23 @@ class Pry
       head = target
     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
+
     # Enter the matrix
     pry_instance.repl(head)
   end
 
+  # Execute the file through the REPL loop, non-interactively.
+  # @param [String] file_name File name to load through the REPL.
+  def self.load_file_through_repl(file_name)
+    require "pry/repl_file_loader"
+    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.
@@ -178,7 +200,7 @@ class Pry
 
   # Run a Pry command from outside a session. The commands available are
   # those referenced by `Pry.commands` (the default command set).
-  # @param [String] arg_string The Pry command (including arguments,
+  # @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.
@@ -234,10 +256,11 @@ class Pry
     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 = true
+    config.auto_indent = Helpers::BaseHelpers.use_ansi_codes?
     config.correct_indent = true
     config.collision_warning = false
 
@@ -312,7 +335,6 @@ class Pry
     self.current_line = 1
     self.line_buffer = [""]
     self.eval_path = "(pry)"
-    self.active_sessions = 0
 
     fix_coderay_colors
   end
@@ -328,7 +350,7 @@ class Pry
                  begin
                    require 'coderay/encoders/term'
                    CodeRay::Encoders::Term::TOKEN_COLORS
-                 rescue => e
+                 rescue
                  end
                end
 
@@ -363,4 +385,14 @@ class Pry
   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.__pry__
+  binding
+end
+Pry.toplevel_binding = __pry__
+Pry.toplevel_binding.eval("private")
+class << self; undef __pry__; end
+
 Pry.init

data/lib/pry/pry_instance.rb

@@ -1,5 +1,26 @@
 require "pry/indent"
 
+##
+# Pry is a powerful alternative to the standard IRB shell for Ruby. It
+# features syntax highlighting, a flexible plugin architecture, runtime
+# invocation and source and documentation browsing.
+#
+# Pry can be started similar to other command line utilities by simply running
+# the following command:
+#
+#     pry
+#
+# Once inside Pry you can invoke the help message:
+#
+#     help
+#
+# This will show a list of available commands and their usage. For more
+# information about Pry you can refer to the following resources:
+#
+# * http://pry.github.com/
+# * https://github.com/pry/pry
+# * the IRC channel, which is #pry on the Freenode network
+#
 class Pry
 
   attr_accessor :input
@@ -28,6 +49,11 @@ class Pry
 
   attr_accessor :extra_sticky_locals
 
+  attr_accessor :suppress_output
+
+  # This is exposed via Pry::Command#state.
+  attr_reader :command_state
+
   # Special treatment for hooks as we want to alert people of the
   # changed API
   attr_reader :hooks
@@ -57,8 +83,9 @@ class Pry
   def initialize(options={})
     refresh(options)
 
-    @binding_stack     = []
-    @indent            = Pry::Indent.new
+    @binding_stack = []
+    @indent        = Pry::Indent.new
+    @command_state = {}
   end
 
   # Refresh the Pry instance settings from the Pry class.
@@ -117,7 +144,7 @@ class Pry
   # @return [Object] The value the local was set to.
   def inject_local(name, value, b)
     Thread.current[:__pry_local__] = value.is_a?(Proc) ? value.call : value
-    b.eval("#{name} = Thread.current[:__pry_local__]")
+    b.eval("#{name} = ::Thread.current[:__pry_local__]")
   ensure
     Thread.current[:__pry_local__] = nil
   end
@@ -172,7 +199,6 @@ class Pry
 
     @input_array << nil # add empty input so _in_ and _out_ match
 
-    Pry.active_sessions += 1
     binding_stack.push target
   end
 
@@ -181,9 +207,8 @@ class Pry
   def repl_epilogue(target)
     exec_hook :after_session, output, target, self
 
-    Pry.active_sessions -= 1
     binding_stack.pop
-    Pry.save_history if Pry.config.history.should_save && Pry.active_sessions == 0
+    Pry.save_history if Pry.config.history.should_save
   end
 
   # Start a read-eval-print-loop.
@@ -196,7 +221,6 @@ class Pry
   #   Pry.new.repl(Object.new)
   def repl(target=TOPLEVEL_BINDING)
     target = Pry.binding_for(target)
-    target_self = target.eval('self')
 
     repl_prologue(target)
 
@@ -246,6 +270,8 @@ class Pry
 
     code = r(target)
 
+    exec_hook :before_eval, code, self
+
     result = target.eval(code, Pry.eval_path, Pry.current_line)
     set_last_result(result, target, code)
 
@@ -272,12 +298,11 @@ class Pry
     target = Pry.binding_for(target)
     @suppress_output = false
 
-    val = ""
     loop do
       begin
         # eval_string will probably be mutated by this method
         retrieve_line(eval_string, target)
-      rescue CommandError, Slop::InvalidOptionError => e
+      rescue CommandError, Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
         output.puts "Error: #{e.message}"
       end
 
@@ -298,9 +323,9 @@ class Pry
   # Output the result or pass to an exception handler (if result is an exception).
   def show_result(result)
     if last_result_is_exception?
-      exception_handler.call output, result, self
+      exception_handler.call(output, result, self)
     else
-      print.call output, result
+      print.call(output, result)
     end
   rescue RescuableException => e
     # Being uber-paranoid here, given that this exception arose because we couldn't
@@ -346,7 +371,7 @@ class Pry
     # Handle <Ctrl+C> like Bash, empty the current input buffer but do not quit.
     # This is only for ruby-1.9; other versions of ruby do not let you send Interrupt
     # from within Readline.
-    rescue Interrupt => e
+    rescue Interrupt
       output.puts ""
       eval_string.replace("")
       return
@@ -514,6 +539,7 @@ class Pry
   # Manage switching of input objects on encountering EOFErrors
   def handle_read_errors
     should_retry = true
+    exception_count = 0
     begin
       yield
     rescue EOFError
@@ -527,6 +553,7 @@ class Pry
       else
         self.input = input_stack.pop
       end
+
       retry
 
     # Interrupts are handled in r() because they need to tweak eval_string
@@ -539,6 +566,11 @@ class Pry
     # anything about it.
     rescue RescuableException => e
       puts "Error: #{e.message}"
+      output.puts e.backtrace
+      exception_count += 1
+      if exception_count < 5
+        retry
+      end
       puts "FATAL: Pry failed to get user input using `#{input}`."
       puts "To fix this you may be able to pass input and output file descriptors to pry directly. e.g."
       puts "  Pry.config.input = STDIN"
@@ -594,15 +626,40 @@ class Pry
   def select_prompt(eval_string, target)
     target_self = target.eval('self')
 
+    open_token = @indent.open_delimiters.any? ? @indent.open_delimiters.last :
+      @indent.stack.last
+
+    c = OpenStruct.new(
+                       :object         => target_self,
+                       :nesting_level  => binding_stack.size - 1,
+                       :open_token     => open_token,
+                       :session_line   => Pry.history.session_line_count + 1,
+                       :history_line   => Pry.history.history_line_count + 1,
+                       :expr_number    => input_array.count,
+                       :_pry_          => self,
+                       :binding_stack  => binding_stack,
+                       :input_array    => input_array,
+                       :eval_string    => eval_string,
+                       :cont           => !eval_string.empty?)
+
     # If input buffer is empty then use normal prompt
     if eval_string.empty?
-      Array(prompt).first.call(target_self, binding_stack.size - 1, self)
+      generate_prompt(Array(prompt).first, c)
 
     # Otherwise use the wait prompt (indicating multi-line expression)
     else
-      Array(prompt).last.call(target_self, binding_stack.size - 1, self)
+      generate_prompt(Array(prompt).last, c)
+    end
+  end
+
+  def generate_prompt(prompt_proc, conf)
+    if prompt_proc.arity == 1
+      prompt_proc.call(conf)
+    else
+      prompt_proc.call(conf.object, conf.nesting_level, conf._pry_)
     end
   end
+  private :generate_prompt
 
   # the array that the prompt stack is stored in
   def prompt_stack

data/lib/pry/repl_file_loader.rb

@@ -0,0 +1,80 @@
+class Pry
+
+  # A class to manage the loading of files through the REPL loop.
+  # This is an interesting trick as it processes your file as if it
+  # was user input in an interactive session. As a result, all Pry
+  # commands are available, and they are executed non-interactively. Furthermore
+  # the session becomes interactive when the repl loop processes a
+  # 'make-interactive' command in the file. The session also becomes
+  # interactive when an exception is encountered, enabling you to fix
+  # the error before returning to non-interactive processing with the
+  # 'make-non-interactive' command.
+
+  class REPLFileLoader
+    def initialize(file_name)
+      full_name = File.expand_path(file_name)
+      raise RuntimeError, "No such file: #{full_name}" if !File.exists?(full_name)
+
+      @content = StringIO.new(File.read(full_name))
+    end
+
+    # Switch to interactive mode, i.e take input from the user
+    # and use the regular print and exception handlers.
+    # @param [Pry] _pry_ the Pry instance to make interactive.
+    def interactive_mode(_pry_)
+      _pry_.input = Pry.config.input
+      _pry_.print = Pry.config.print
+      _pry_.exception_handler = Pry.config.exception_handler
+    end
+
+    # Switch to non-interactive mode. Essentially
+    # this means there is no result output
+    # and that the session becomes interactive when an exception is encountered.
+    # @param [Pry] _pry_ the Pry instance to make non-interactive.
+    def non_interactive_mode(_pry_)
+      _pry_.print = proc {}
+      _pry_.exception_handler = proc do |o, e, _pry_|
+        _pry_.run_command "cat --ex"
+        o.puts "...exception encountered, going interactive!"
+        interactive_mode(_pry_)
+      end
+    end
+
+    # Define a few extra commands useful for flipping back & forth
+    # between interactive/non-interactive modes
+    def define_additional_commands
+      s = self
+
+      Pry::Commands.command "make-interactive", "Make the session interactive" do
+        _pry_.input_stack.push _pry_.input
+        s.interactive_mode(_pry_)
+      end
+
+      Pry::Commands.command "make-non-interactive", "Make the session non-interactive" do
+        _pry_.input = _pry_.input_stack.pop
+        s.non_interactive_mode(_pry_)
+      end
+
+      Pry::Commands.command "load-file", "Load another file through the repl" do |file_name|
+        content = StringIO.new(File.read(File.expand_path(file_name)))
+        _pry_.input_stack.push(_pry_.input)
+        _pry_.input = content
+      end
+    end
+
+    # Actually load the file through the REPL by setting file content
+    # as the REPL input stream.
+    def load
+      Pry.initial_session_setup
+      define_additional_commands
+
+      Pry.config.hooks.add_hook(:when_started, :start_non_interactively) do |o, t, _pry_|
+        non_interactive_mode(_pry_)
+      end
+
+      Pry.start(Pry.toplevel_binding,
+                :input => @content,
+                :input_stack => [StringIO.new("exit-all\n")])
+    end
+  end
+end

data/lib/pry/version.rb

@@ -1,3 +1,3 @@
 class Pry
-  VERSION = "0.9.9.6pre2"
+  VERSION = "0.9.10"
 end