pry 0.9.10pre1-i386-mingw32 → 0.9.11-i386-mingw32

data/lib/pry/pager.rb

@@ -0,0 +1,70 @@
+class Pry::Pager
+  # @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?
+      is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+      (is_jruby || no_pager) ? SimplePager.new(text).page : SystemPager.new(text).page
+    when :simple
+      SimplePager.new(text).page
+    when :system
+      SystemPager.new(text).page
+    else
+      raise "'#{pager}' is not a recognized pager."
+    end
+  end
+
+  def self.page_size
+    27
+  end
+
+  def initialize(text)
+    @text = text
+  end
+
+  class SimplePager < Pry::Pager
+    def page
+      text_array = @text.lines.to_a
+      text_array.each_slice(Pry::Pager.page_size) do |chunk|
+        puts chunk.join
+        break if chunk.size < Pry::Pager.page_size
+        if text_array.size > Pry::Pager.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
+
+  class SystemPager < Pry::Pager
+    def self.default_pager
+      ENV["PAGER"] || "less -R -S -F -X"
+    end
+
+    def self.available?
+      pager_executable = default_pager.split(' ').first
+      `which #{ pager_executable }`
+    rescue
+    end
+
+    def initialize(*)
+      super
+      @pager = SystemPager.default_pager
+    end
+
+    def page
+      IO.popen(@pager, 'w') do |io|
+        io.write @text
+      end
+    end
+  end
+end

data/lib/pry/plugins.rb

@@ -48,7 +48,7 @@ class Pry
         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
         end
 
@@ -99,4 +99,3 @@ class Pry
   end
 
 end
-

data/lib/pry/pry_class.rb

@@ -5,9 +5,14 @@ require 'pry/config'
 class Pry
 
   # The RC Files to load.
-  RC_FILES = ["~/.pryrc"]
+  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
@@ -57,29 +62,28 @@ 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)
+      toplevel_binding.eval(File.read(full_name), full_name) if File.exists?(full_name)
     rescue RescuableException => e
-      puts "Error loading #{file_name}: #{e}"
+      puts "Error loading #{file_name}: #{e}\n#{e.backtrace.first}"
     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
-    RC_FILES.uniq.each do |file_name|
-      load_file_at_toplevel(file_name)
-    end
+    load_file_at_toplevel(HOME_RC_FILE)
   end
 
   # Load the local RC file (./.pryrc)
   def self.load_local_rc
-    load_file_at_toplevel(LOCAL_RC_FILE)
+    unless File.expand_path(HOME_RC_FILE) == File.expand_path(LOCAL_RC_FILE)
+      load_file_at_toplevel(LOCAL_RC_FILE)
+    end
   end
 
   # Load any Ruby files specified with the -r flag on the command line.
@@ -115,15 +119,23 @@ class Pry
   end
 
   # Start a Pry REPL.
-  # This method also loads the files specified in `Pry::RC_FILES` the
+  # This method also loads the ~/.pryrc and ./.pryrc as necessary
   # 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)
+  def self.start(target=nil, options={})
+    return if ENV['DISABLE_PRY']
+
+    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
+
+    target = Pry.binding_for(target || toplevel_binding)
     initial_session_setup
 
     # create the Pry instance to manage the session
@@ -152,6 +164,9 @@ class Pry
 
     # Enter the matrix
     pry_instance.repl(head)
+  rescue Pry::TooSafeException
+    puts "ERROR: Pry cannot work with $SAFE > 0"
+    raise
   end
 
   # Execute the file through the REPL loop, non-interactively.
@@ -244,6 +259,7 @@ class Pry
     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
@@ -263,6 +279,13 @@ class Pry
     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
+    else
+      config.completer = Pry::InputCompleter
+    end
 
     config.gist ||= OpenStruct.new
     config.gist.inspecter = proc(&:pretty_inspect)
@@ -297,8 +320,8 @@ class Pry
       :protected_method_color   => :yellow,
       :method_missing_color     => :bright_red,
 
-      :local_var_color          => :default,
-      :pry_var_color            => :red,         # e.g. _, _pry_, _file_
+      :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
@@ -383,16 +406,34 @@ class Pry
       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 @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.in_critical_section?
+    @critical_section.to_i > 0
+  end
+
+  def self.critical_section(&block)
+    @critical_section = @critical_section.to_i + 1
+    yield
+  ensure
+    @critical_section -= 1
+  end
 end
-Pry.toplevel_binding = __binding_impl__
-Pry.toplevel_binding.eval("private")
-class << self; undef __binding_impl__; end
 
 Pry.init

data/lib/pry/pry_instance.rb

@@ -97,13 +97,15 @@ class Pry
     attributes = [
                    :input, :output, :commands, :print, :quiet,
                    :exception_handler, :hooks, :custom_completions,
-                   :prompt, :memory_size, :input_stack, :extra_sticky_locals
+                   :prompt, :memory_size, :extra_sticky_locals
                  ]
 
     attributes.each do |attribute|
       defaults[attribute] = Pry.send attribute
     end
 
+    defaults[:input_stack] = Pry.input_stack.dup
+
     defaults.merge!(options).each do |key, value|
       send("#{key}=", value) if respond_to?("#{key}=")
     end
@@ -143,10 +145,10 @@ class Pry
   # @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.is_a?(Proc) ? value.call : value
-    b.eval("#{name} = ::Thread.current[:__pry_local__]")
+    Pry.current[:pry_local] = value.is_a?(Proc) ? value.call : value
+    b.eval("#{name} = ::Pry.current[:pry_local]")
   ensure
-    Thread.current[:__pry_local__] = nil
+    Pry.current[:pry_local] = nil
   end
 
   # @return [Integer] The maximum amount of objects remembered by the inp and
@@ -186,7 +188,8 @@ class Pry
       :_ex_   => proc { last_exception },
       :_file_ => proc { last_file },
       :_dir_  => proc { last_dir },
-      :_      => proc { last_result }
+      :_      => proc { last_result },
+      :__     => proc { @output_array[-2] }
     }.merge(extra_sticky_locals)
   end
 
@@ -196,7 +199,6 @@ class Pry
     exec_hook :before_session, output, target, self
     set_last_result(nil, target)
 
-
     @input_array << nil # add empty input so _in_ and _out_ match
 
     binding_stack.push target
@@ -228,6 +230,7 @@ class Pry
     exception = catch(:raise_up) do
       break_data = catch(:breakout) do
         loop do
+          throw(:breakout) if binding_stack.empty?
           rep(binding_stack.last)
         end
       end
@@ -250,7 +253,9 @@ class Pry
     target = Pry.binding_for(target)
     result = re(target)
 
-    show_result(result) if should_print?
+    Pry.critical_section do
+      show_result(result)
+    end
   end
 
   # Perform a read-eval
@@ -265,23 +270,15 @@ class Pry
     target = Pry.binding_for(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`)
+    # moved into the scope of a new Binding (e.g the user typed `cd`).
     inject_sticky_locals(target)
 
     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)
-
-    result
+    evaluate_ruby(code, target)
   rescue RescuableException => e
     self.last_exception = e
     e
-  ensure
-    update_input_history(code)
-    exec_hook :after_eval, result, self
   end
 
   # Perform a read.
@@ -309,23 +306,39 @@ class Pry
       begin
         break if Pry::Code.complete_expression?(eval_string)
       rescue SyntaxError => e
-        output.puts "SyntaxError: #{e.message.sub(/.*syntax error, */m, '')}"
+        exception_handler.call(output, e.extend(UserError), self)
         eval_string = ""
       end
     end
 
-    @suppress_output = true if eval_string =~ /;\Z/ || eval_string.empty?
+    if eval_string =~ /;\Z/ || eval_string.empty? || eval_string =~ /\A *#.*\n\z/
+      @suppress_output = true
+    end
 
     exec_hook :after_read, eval_string, self
     eval_string
   end
 
+  def evaluate_ruby(code, target = binding_stack.last)
+    target = Pry.binding_for(target)
+    inject_sticky_locals(target)
+    exec_hook :before_eval, code, self
+
+    result = target.eval(code, Pry.eval_path, Pry.current_line)
+    set_last_result(result, target, code)
+  ensure
+    update_input_history(code)
+    exec_hook :after_eval, result, self
+  end
+
   # 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)
-    else
+    elsif should_print?
       print.call(output, result)
+    else
+      # nothin'
     end
   rescue RescuableException => e
     # Being uber-paranoid here, given that this exception arose because we couldn't
@@ -359,14 +372,15 @@ class Pry
     @indent.reset if eval_string.empty?
 
     current_prompt = select_prompt(eval_string, target)
-    completion_proc = Pry::InputCompleter.build_completion_proc(target,
+    completion_proc = Pry.config.completer.build_completion_proc(target, self,
                                                         instance_eval(&custom_completions))
 
+    safe_completion_proc = proc{ |*a| Pry.critical_section{ completion_proc.call(*a) } }
 
     indentation = Pry.config.auto_indent ? @indent.current_prefix : ''
 
     begin
-      val = readline("#{current_prompt}#{indentation}", completion_proc)
+      val = readline("#{current_prompt}#{indentation}", safe_completion_proc)
 
     # 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
@@ -403,12 +417,16 @@ class Pry
       indented_val = val
     end
 
+    # Check this before processing the line, because a command might change
+    # Pry's input.
+    interactive = !input.is_a?(StringIO)
+
     begin
       if !process_command(val, eval_string, target)
-        eval_string << "#{indented_val.rstrip}\n" unless val.empty?
+        eval_string << "#{indented_val.chomp}\n" unless val.empty?
       end
     ensure
-      Pry.history << indented_val unless input.is_a?(StringIO)
+      Pry.history << indented_val if interactive
     end
   end
 
@@ -419,7 +437,8 @@ class Pry
   # @param [String] eval_string The cumulative lines of input.
   # @param [Binding] target The target of the Pry session.
   # @return [Boolean] `true` if `val` is a command, `false` otherwise
-  def process_command(val, eval_string, target)
+  def process_command(val, eval_string = '', target = binding_stack.last)
+    val = val.chomp
     result = commands.process_line(val, {
       :target => target,
       :output => output,
@@ -428,7 +447,7 @@ class Pry
     })
 
     # set a temporary (just so we can inject the value we want into eval_string)
-    Thread.current[:__pry_cmd_result__] = result
+    Pry.current[:pry_cmd_result] = result
 
     # note that `result` wraps the result of command processing; if a
     # command was matched and invoked then `result.command?` returns true,
@@ -438,7 +457,7 @@ class Pry
         # 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"
+        eval_string.replace "::Pry.current[:pry_cmd_result].retval\n"
       end
       true
     else
@@ -590,7 +609,8 @@ class Pry
 
       if defined? Coolline and input.is_a? Coolline
         input.completion_proc = proc do |cool|
-          completion_proc.call cool.completed_word
+          completions = completion_proc.call cool.completed_word
+          completions.compact
         end
       elsif input.respond_to? :completion_proc=
         input.completion_proc = completion_proc
@@ -611,11 +631,10 @@ class Pry
   end
 
   # Whether the print proc should be invoked.
-  # Currently only invoked if the output is not suppressed OR the last result
-  # is an exception regardless of suppression.
+  # Currently only invoked if the output is not suppressed.
   # @return [Boolean] Whether the print proc should be invoked.
   def should_print?
-    !@suppress_output || last_result_is_exception?
+    !@suppress_output
   end
 
   # Returns the appropriate prompt to use.
@@ -642,13 +661,15 @@ class Pry
                        :eval_string    => eval_string,
                        :cont           => !eval_string.empty?)
 
-    # If input buffer is empty then use normal prompt
-    if eval_string.empty?
-      generate_prompt(Array(prompt).first, c)
+    Pry.critical_section do
+      # If input buffer is empty then use normal prompt
+      if eval_string.empty?
+        generate_prompt(Array(prompt).first, c)
 
-    # Otherwise use the wait prompt (indicating multi-line expression)
-    else
-      generate_prompt(Array(prompt).last, c)
+      # Otherwise use the wait prompt (indicating multi-line expression)
+      else
+        generate_prompt(Array(prompt).last, c)
+      end
     end
   end