pry 0.9.8.4-i386-mingw32 → 0.9.9-i386-mingw32

data/lib/pry/pry_class.rb

@@ -46,11 +46,14 @@ class Pry
     # @return [Fixnum] The number of active Pry sessions.
     attr_accessor :active_sessions
 
+    # @return [Boolean] Whether Pry sessions are quiet by default.
+    attr_accessor :quiet
+
     # plugin forwardables
     def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
 
     delegate_accessors :@config, :input, :output, :commands, :prompt, :print, :exception_handler,
-      :hooks, :color, :pager, :editor, :memory_size, :input_stack
+      :hooks, :color, :pager, :editor, :memory_size, :input_stack, :extra_sticky_locals
   end
 
   # Load the rc files given in the `Pry::RC_FILES` array.
@@ -261,6 +264,8 @@ class Pry
 
     config.memory_size = 100
 
+    config.extra_sticky_locals = {}
+
     config.ls ||= OpenStruct.new({
       :heading_color            => :default,
 
@@ -279,9 +284,10 @@ class Pry
       :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
+      :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                => "  ",
@@ -345,7 +351,7 @@ class Pry
   # @param [Object] target The object to get a `Binding` object for.
   # @return [Binding] The `Binding` object.
   def self.binding_for(target)
-    if target.is_a?(Binding)
+    if Binding === target
       target
     else
       if TOPLEVEL_BINDING.eval('self') == target

data/lib/pry/pry_instance.rb

@@ -8,6 +8,8 @@ class Pry
   attr_accessor :print
   attr_accessor :exception_handler
   attr_accessor :input_stack
+  attr_accessor :quiet
+  alias :quiet? :quiet
 
   attr_accessor :custom_completions
 
@@ -24,6 +26,8 @@ class Pry
 
   attr_accessor :backtrace
 
+  attr_accessor :extra_sticky_locals
+
   # Special treatment for hooks as we want to alert people of the
   # changed API
   attr_reader :hooks
@@ -48,6 +52,7 @@ class Pry
   # @option options [Hash] :hooks The defined hook Procs
   # @option options [Array<Proc>] :prompt The array of Procs to use for the prompts.
   # @option options [Proc] :print The Proc to use for the 'print'
+  # @option options [Boolean] :quiet If true, omit the whereami banner when starting.
   #   component of the REPL. (see print.rb)
   def initialize(options={})
     refresh(options)
@@ -63,9 +68,9 @@ class Pry
   def refresh(options={})
     defaults   = {}
     attributes = [
-                   :input, :output, :commands, :print,
+                   :input, :output, :commands, :print, :quiet,
                    :exception_handler, :hooks, :custom_completions,
-                   :prompt, :memory_size, :input_stack
+                   :prompt, :memory_size, :input_stack, :extra_sticky_locals
                  ]
 
     attributes.each do |attribute|
@@ -155,7 +160,7 @@ class Pry
       :_file_ => proc { last_file },
       :_dir_  => proc { last_dir },
       :_      => proc { last_result }
-    }
+    }.merge(extra_sticky_locals)
   end
 
   # Initialize the repl session.
@@ -195,13 +200,19 @@ class Pry
 
     repl_prologue(target)
 
-    break_data = catch(:breakout) do
-      loop do
-        rep(binding_stack.last)
+    break_data = nil
+    exception = catch(:raise_up) do
+      break_data = catch(:breakout) do
+        loop do
+          rep(binding_stack.last)
+        end
       end
+      exception = false
     end
 
-    break_data || nil
+    raise exception if exception
+
+    break_data
   ensure
     repl_epilogue(target)
   end
@@ -229,17 +240,6 @@ class Pry
   def re(target=TOPLEVEL_BINDING)
     target = Pry.binding_for(target)
 
-    compl = Pry::InputCompleter.build_completion_proc(target,
-                                                      instance_eval(&custom_completions))
-
-    if defined? Coolline and input.is_a? Coolline
-      input.completion_proc = proc do |cool|
-        compl.call cool.completed_word
-      end
-    elsif input.respond_to? :completion_proc=
-      input.completion_proc = compl
-    end
-
     # 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_sticky_locals(target)
@@ -282,7 +282,7 @@ class Pry
       end
 
       begin
-        break if complete_expression?(eval_string)
+        break if Pry::Code.complete_expression?(eval_string)
       rescue SyntaxError => e
         output.puts "SyntaxError: #{e.message.sub(/.*syntax error, */m, '')}"
         eval_string = ""
@@ -334,9 +334,23 @@ class Pry
     @indent.reset if eval_string.empty?
 
     current_prompt = select_prompt(eval_string, target)
+    completion_proc = Pry::InputCompleter.build_completion_proc(target,
+                                                        instance_eval(&custom_completions))
+
+
     indentation = Pry.config.auto_indent ? @indent.indent_level : ''
 
-    val = readline("#{current_prompt}#{indentation}")
+    begin
+      val = readline("#{current_prompt}#{indentation}", 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
+    # from within Readline.
+    rescue Interrupt => e
+      output.puts ""
+      eval_string.replace("")
+      return
+    end
 
     # invoke handler if we receive EOF character (^D)
     if !val
@@ -356,8 +370,8 @@ class Pry
       original_val = "#{indentation}#{val}"
       indented_val = @indent.indent(val)
 
-      if original_val != indented_val && output.tty? && Pry::Helpers::BaseHelpers.use_ansi_codes? && Pry.config.correct_indent
-        output.print @indent.correct_indentation(current_prompt + indented_val, original_val.length - indented_val.length)
+      if output.tty? && Pry::Helpers::BaseHelpers.use_ansi_codes? && Pry.config.correct_indent
+        output.print @indent.correct_indentation(current_prompt, indented_val, original_val.length - indented_val.length)
         output.flush
       end
     else
@@ -514,17 +528,42 @@ class Pry
         self.input = input_stack.pop
       end
       retry
+
+    # Interrupts are handled in r() because they need to tweak eval_string
+    # TODO: Refactor this baby.
+    rescue Interrupt
+      raise
+
+    # If we get a random error when trying to read a line we don't want to automatically
+    # retry, as the user will see a lot of error messages scroll past and be unable to do
+    # anything about it.
+    rescue RescuableException => e
+      puts "Error: #{e.message}"
+      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"
+      puts "  Pry.config.output = STDOUT"
+      puts "  binding.pry"
+      throw(:breakout)
     end
   end
-
   private :handle_read_errors
 
   # Returns the next line of input to be used by the pry instance.
   # This method should not need to be invoked directly.
   # @param [String] current_prompt The prompt to use for input.
   # @return [String] The next line of input.
-  def readline(current_prompt="> ")
+  def readline(current_prompt="> ", completion_proc=nil)
     handle_read_errors do
+
+      if defined? Coolline and input.is_a? Coolline
+        input.completion_proc = proc do |cool|
+          completion_proc.call cool.completed_word
+        end
+      elsif input.respond_to? :completion_proc=
+        input.completion_proc = completion_proc
+      end
+
       if input == Readline
         input.readline(current_prompt, false) # false since we'll add it manually
       elsif defined? Coolline and input.is_a? Coolline
@@ -598,50 +637,45 @@ class Pry
     prompt_stack.size > 1 ? prompt_stack.pop : prompt
   end
 
-  # Determine if a string of code is a complete Ruby expression.
-  # @param [String] code The code to validate.
-  # @return [Boolean] Whether or not the code is a complete Ruby expression.
-  # @raise [SyntaxError] Any SyntaxError that does not represent incompleteness.
-  # @example
-  #   complete_expression?("class Hello") #=> false
-  #   complete_expression?("class Hello; end") #=> true
-  def complete_expression?(str)
-    if defined?(Rubinius::Melbourne19) && RUBY_VERSION =~ /^1\.9/
-      Rubinius::Melbourne19.parse_string(str, Pry.eval_path)
-    elsif defined?(Rubinius::Melbourne)
-      Rubinius::Melbourne.parse_string(str, Pry.eval_path)
-    else
-      catch(:valid) do
-        Helpers::BaseHelpers.silence_warnings do
-          eval("BEGIN{throw :valid}\n#{str}", binding, Pry.eval_path)
-        end
-      end
-    end
-
-    # Assert that a line which ends with a , is incomplete.
-    str !~ /[,]\z/
-  rescue SyntaxError => e
-    if incomplete_user_input_exception?(e)
-      false
-    else
-      raise e
-    end
-  end
-
-  # Check whether the exception indicates that the user should input more.
+  # Raise an exception out of Pry.
   #
-  # @param [SyntaxError] the exception object that was raised.
-  # @param [Array<String>] The stack frame of the function that executed eval.
-  # @return [Boolean]
+  # See Kernel#raise for documentation of parameters.
+  # See rb_make_exception for the inbuilt implementation.
   #
-  def incomplete_user_input_exception?(ex)
-    case ex.message
-    when /unexpected (\$end|end-of-file|END_OF_FILE)/, # mri, jruby, ironruby
-        /unterminated (quoted string|string|regexp) meets end of file/, # "quoted string" is ironruby
-        /missing 'end' for/, /: expecting '[})\]]'$/, /can't find string ".*" anywhere before EOF/, /expecting keyword_end/ # rbx
-      true
+  # This is necessary so that the raise-up command can tell the
+  # difference between an exception the user has decided to raise,
+  # and a mistake in specifying that exception.
+  #
+  # (i.e. raise-up RunThymeError.new should not be the same as
+  #  raise-up NameError, "unititialized constant RunThymeError")
+  #
+  def raise_up_common(force, *args)
+    exception = if args == []
+                  last_exception || RuntimeError.new
+                elsif args.length == 1 && args.first.is_a?(String)
+                  RuntimeError.new(args.first)
+                elsif args.length > 3
+                  raise ArgumentError, "wrong number of arguments"
+                elsif !args.first.respond_to?(:exception)
+                  raise TypeError, "exception class/object expected"
+                elsif args.length === 1
+                  args.first.exception
+                else
+                  args.first.exception(args[1])
+                end
+
+    raise TypeError, "exception object expected" unless exception.is_a? Exception
+
+    exception.set_backtrace(args.length === 3 ? args[2] : caller(1))
+
+    if force || binding_stack.one?
+      binding_stack.clear
+      throw :raise_up, exception
     else
-      false
+      binding_stack.pop
+      raise exception
     end
   end
+  def raise_up(*args); raise_up_common(false, *args); end
+  def raise_up!(*args); raise_up_common(true, *args); end
 end

data/lib/pry/rbx_method.rb

@@ -1,20 +1,13 @@
 class Pry
   module RbxMethod
     private
-    def core?
-      source_file and RbxPath.is_core_path?(source_file)
-    end
 
     def core_code
-      MethodSource.source_helper(core_path_line)
+      MethodSource.source_helper(source_location)
     end
 
     def core_doc
-      MethodSource.comment_helper(core_path_line)
-    end
-
-    def core_path_line
-      [RbxPath.convert_path_to_full(source_file), source_line]
+      MethodSource.comment_helper(source_location)
     end
   end
 end

data/lib/pry/version.rb

@@ -1,3 +1,3 @@
 class Pry
-  VERSION = "0.9.8.4"
+  VERSION = "0.9.9"
 end

data/lib/pry/wrapped_module.rb

@@ -1,15 +1,55 @@
+require 'pry/helpers/documentation_helpers'
+
 class Pry
+  class << self
+    # If the given object is a `Pry::WrappedModule`, return it unaltered. If it's
+    # anything else, return it wrapped in a `Pry::WrappedModule` instance.
+    def WrappedModule(obj)
+      if obj.is_a? Pry::WrappedModule
+        obj
+      else
+        Pry::WrappedModule.new(obj)
+      end
+    end
+  end
+
   class WrappedModule
+    include Helpers::DocumentationHelpers
 
     attr_reader :wrapped
     private :wrapped
 
+    # Convert a string to a module.
+    #
+    # @param [String] mod_name
+    # @param [Binding] target The binding where the lookup takes place.
+    # @return [Module, nil] The module or `nil` (if conversion failed).
+    # @example
+    #   Pry::WrappedModule.from_str("Pry::Code")
+    def self.from_str(mod_name, target=TOPLEVEL_BINDING)
+      kind = target.eval("defined?(#{mod_name})")
+
+      # if we dont limit it to constants then from_str could end up
+      # executing methods which is not good, i.e `show-source pry`
+      if (kind == "constant" && target.eval(mod_name).is_a?(Module))
+        Pry::WrappedModule.new(target.eval(mod_name))
+      else
+        nil
+      end
+    rescue RescuableException
+      nil
+    end
+
     # Create a new WrappedModule
     # @raise ArgumentError, if the argument is not a Module
     # @param [Module]
     def initialize(mod)
       raise ArgumentError, "Tried to initialize a WrappedModule with a non-module #{mod.inspect}" unless ::Module === mod
       @wrapped = mod
+      @host_file_lines = nil
+      @source = nil
+      @source_location = nil
+      @doc = nil
     end
 
     # The prefix that would appear before methods defined on this class.
@@ -67,7 +107,202 @@ class Pry
     end
 
     def respond_to?(method_name)
-      super || wrapped.send(method_name, *args, &block)
+      super || wrapped.respond_to?(method_name)
+    end
+
+    def yard_docs?
+      !!(defined?(YARD) && YARD::Registry.at(name))
+    end
+
+    def process_doc(doc)
+      process_comment_markup(strip_leading_hash_and_whitespace_from_ruby_comments(doc),
+                             :ruby)
+    end
+
+    def doc
+      return @doc if @doc
+
+      file_name, line = source_location
+
+      if yard_docs?
+        from_yard = YARD::Registry.at(name)
+        @doc = from_yard.docstring
+      elsif source_location.nil?
+        raise CommandError, "Can't find module's source location"
+      else
+        @doc = extract_doc_for_candidate(0)
+      end
+
+      raise CommandError, "Can't find docs for module: #{name}." if !@doc
+
+      @doc = process_doc(@doc)
+    end
+
+    def doc_for_candidate(idx)
+      doc = extract_doc_for_candidate(idx)
+      raise CommandError, "Can't find docs for module: #{name}." if !doc
+
+      process_doc(doc)
+    end
+
+    # Retrieve the source for the module.
+    def source
+      @source ||= source_for_candidate(0)
     end
+
+    def source_for_candidate(idx)
+      file, line = module_source_location_for_candidate(idx)
+      raise CommandError, "Could not locate source for #{wrapped}!" if file.nil?
+
+      strip_leading_whitespace(Pry::Code.retrieve_complete_expression_from(lines_for_file(file)[(line - 1)..-1]))
+    end
+
+    def source_file
+      if yard_docs?
+        from_yard = YARD::Registry.at(name)
+        from_yard.file
+      else
+        source_file_for_candidate(0)
+      end
+    end
+
+    def source_line
+      source_line_for_candidate(0)
+    end
+
+    def source_file_for_candidate(idx)
+      Array(module_source_location_for_candidate(idx)).first
+    end
+
+    def source_line_for_candidate(idx)
+      Array(module_source_location_for_candidate(idx)).last
+    end
+
+    # Retrieve the source location of a module. Return value is in same
+    # format as Method#source_location. If the source location
+    # cannot be found this method returns `nil`.
+    #
+    # @param [Module] mod The module (or class).
+    # @return [Array<String, Fixnum>] The source location of the
+    #   module (or class).
+    def source_location
+      @source_location ||= module_source_location_for_candidate(0)
+    rescue Pry::RescuableException
+      nil
+    end
+
+    # memoized lines for file
+    def lines_for_file(file)
+      @lines_for_file ||= {}
+
+      if file == Pry.eval_path
+       @lines_for_file[file] ||= Pry.line_buffer.drop(1)
+      else
+       @lines_for_file[file] ||= File.readlines(file)
+      end
+    end
+
+    def module_source_location_for_candidate(idx)
+      mod_type_string = wrapped.class.to_s.downcase
+      file, line = method_source_location_for_candidate(idx)
+
+      return nil if !file.is_a?(String)
+
+      class_regex1 = /#{mod_type_string}\s*(\w*)(::)?#{wrapped.name.split(/::/).last}/
+      class_regex2 = /(::)?#{wrapped.name.split(/::/).last}\s*?=\s*?#{wrapped.class}/
+
+      host_file_lines = lines_for_file(file)
+
+      search_lines = host_file_lines[0..(line - 2)]
+      idx = search_lines.rindex { |v| class_regex1 =~ v  || class_regex2 =~ v }
+
+      source_location = [file,  idx + 1]
+    rescue Pry::RescuableException
+      nil
+    end
+
+    def extract_doc
+      extract_doc_for_candidate(0)
+    end
+
+    def extract_doc_for_candidate(idx)
+      file_name, line = module_source_location_for_candidate(idx)
+
+      buffer = ""
+      lines_for_file(source_file_for_candidate(idx))[0..(line - 2)].each do |line|
+        # Add any line that is a valid ruby comment,
+        # but clear as soon as we hit a non comment line.
+        if (line =~ /^\s*#/) || (line =~ /^\s*$/)
+          buffer << line.lstrip
+        else
+          buffer.replace("")
+        end
+      end
+
+      buffer
+    end
+
+    # FIXME: this method is also found in Pry::Method
+    def safe_send(obj, method, *args, &block)
+      (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
+    end
+
+    # FIXME: a variant of this method is also found in Pry::Method
+    def all_from_common(mod, method_type)
+      %w(public protected private).map do |visibility|
+        safe_send(mod, :"#{visibility}_#{method_type}s", false).select do |method_name|
+          if method_type == :method
+            safe_send(mod, method_type, method_name).owner == class << mod; self; end
+          else
+            safe_send(mod, method_type, method_name).owner == mod
+          end
+        end.map do |method_name|
+          Pry::Method.new(safe_send(mod, method_type, method_name), :visibility => visibility.to_sym)
+        end
+      end.flatten
+    end
+
+    def all_methods_for(mod)
+      all_from_common(mod, :instance_method) + all_from_common(mod, :method)
+    end
+
+    def all_source_locations_by_popularity
+      return @all_source_locations_by_popularity if @all_source_locations_by_popularity
+
+      ims = all_methods_for(wrapped)
+
+      ims.reject! do |v|
+        begin
+          v.alias? || v.source_location.nil?
+        rescue Pry::RescuableException
+          true
+        end
+      end
+
+      @all_source_locations_by_popularity = ims.group_by { |v| Array(v.source_location).first }.
+        sort_by { |k, v| -v.size }
+    end
+
+    def method_candidates
+      @method_candidtates ||= all_source_locations_by_popularity.map do |group|
+        sorted_by_lowest_line_number = group.last.sort_by(&:source_line)
+        best_candidate_for_group = sorted_by_lowest_line_number.first
+      end
+    end
+
+    def number_of_candidates
+      method_candidates.count
+    end
+
+    def method_source_location_for_candidate(idx)
+      file, line = method_candidates[idx].source_location
+
+      if file && RbxPath.is_core_path?(file)
+        file = RbxPath.convert_path_to_full(file)
+      end
+
+      [file, line]
+    end
+
   end
 end