pry 0.9.7.4-i386-mswin32 → 0.9.8-i386-mswin32

data/lib/pry/indent.rb

@@ -43,7 +43,11 @@ class Pry
     # Collection of token types that should be ignored. Without this list
     # keywords such as "class" inside strings would cause the code to be
     # indented incorrectly.
-    IGNORE_TOKENS = [:space, :content, :string, :delimiter, :method, :ident]
+    #
+    # :pre_constant and :preserved_constant are the CodeRay 0.9.8 and 1.0.0
+    # classifications of "true", "false", and "nil".
+    IGNORE_TOKENS = [:space, :content, :string, :delimiter, :method, :ident,
+                     :constant, :pre_constant, :predefined_constant]
 
     # Tokens that indicate the end of a statement (i.e. that, if they appear
     # directly before an "if" indicates that that if applies to the same line,
@@ -199,11 +203,11 @@ class Pry
       end
 
       if defined?(Win32::Console)
-        move_up    = "\e[#{lines}F"
-        move_down  = "\e[#{lines}E"
+        move_up   = "\e[#{lines}F"
+        move_down = "\e[#{lines}E"
       else
-        move_up    = "\e[#{lines}A\e[0G"
-        move_down  = "\e[#{lines}B\e[0G"
+        move_up   = "\e[#{lines}A\e[0G"
+        move_down = "\e[#{lines}B\e[0G"
       end
       whitespace = ' ' * overhang
 

data/lib/pry/method.rb

@@ -1,4 +1,17 @@
+# -*- coding: utf-8 -*-
 class Pry
+  class << self
+    # If the given object is a `Pry::Method`, return it unaltered. If it's
+    # anything else, return it wrapped in a `Pry::Method` instance.
+    def Method(obj)
+      if obj.is_a? Pry::Method
+        obj
+      else
+        Pry::Method.new(obj)
+      end
+    end
+  end
+
   class Method
     include RbxMethod if Helpers::BaseHelpers.rbx?
 
@@ -48,7 +61,43 @@ class Pry
         if [:__script__, nil, :__binding__, :__binding_impl__].include?(meth_name)
           nil
         else
-          new(b.eval("method(:#{meth_name})"))
+          method = begin
+                     new(b.eval("method(#{meth_name.to_s.inspect})"))
+                   rescue NameError, NoMethodError
+                     Disowned.new(b.eval('self'), meth_name.to_s)
+                   end
+
+          # it's possible in some cases that the method we find by this approach is a sub-method of
+          # the one we're currently in, consider:
+          #
+          # class A; def b; binding.pry; end; end
+          # class B < A; def b; super; end; end
+          #
+          # Given that we can normally find the source_range of methods, and that we know which
+          # __FILE__ and __LINE__ the binding is at, we can hope to disambiguate these cases.
+          #
+          # This obviously won't work if the source is unavaiable for some reason, or if both
+          # methods have the same __FILE__ and __LINE__, or if we're in rbx where b.eval('__LINE__')
+          # is broken.
+          #
+          guess = method
+
+          while guess
+            # needs rescue if this is a Disowned method or a C method or something...
+            # TODO: Fix up the exception handling so we don't need a bare rescue
+            if (guess.source_file && guess.source_range rescue false) &&
+                File.expand_path(guess.source_file) == File.expand_path(b.eval('__FILE__')) &&
+                guess.source_range.include?(b.eval('__LINE__'))
+              return guess
+            else
+              guess = guess.super
+            end
+          end
+
+          # Uhoh... none of the methods in the chain had the right __FILE__ and __LINE__
+          # This may be caused by rbx https://github.com/rubinius/rubinius/issues/953,
+          # or other unknown circumstances (TODO: we should warn the user when this happens)
+          method
         end
       end
 
@@ -128,7 +177,7 @@ class Pry
       end
 
       # Acts like send but ignores any methods defined below Object or Class in the
-      # inheritance heirarchy.
+      # inheritance hierarchy.
       # This is required to introspect methods on objects like Net::HTTP::Get that
       # have overridden the `method` method.
       def safe_send(obj, method, *args, &block)
@@ -166,6 +215,27 @@ class Pry
       @method.name.to_s
     end
 
+    # Get the owner of the method as a Pry::Module
+    # @return [Pry::Module]
+    def wrapped_owner
+      @wrapped_owner ||= Pry::WrappedModule.new(owner)
+    end
+
+    # Is the method undefined? (aka `Disowned`)
+    # @return [Boolean] false
+    def undefined?
+      false
+    end
+
+    # Get the name of the method including the class on which it was defined.
+    # @example
+    #   method(:puts).method_name
+    #   => "Kernel.puts"
+    # @return [String]
+    def name_with_owner
+      "#{wrapped_owner.method_prefix}#{name}"
+    end
+
     # @return [String, nil] The source code of the method, or `nil` if it's unavailable.
     def source
       @source ||= case source_type
@@ -174,11 +244,11 @@ class Pry
           if info and info.source
             code = strip_comments_from_c_code(info.source)
           end
-        when :rbx
-          strip_leading_whitespace(core_code)
         when :ruby
-          if pry_method?
-            code = Pry.new(:input => StringIO.new(Pry.line_buffer[source_line..-1].join), :prompt => proc {""}, :hooks => {}).r
+          if Helpers::BaseHelpers.rbx? && core?
+            code = core_code
+          elsif pry_method?
+            code = Pry.new(:input => StringIO.new(Pry.line_buffer[source_line..-1].join), :prompt => proc {""}, :hooks => Pry::Hooks.new).r
           else
             code = @method.source
           end
@@ -194,10 +264,10 @@ class Pry
         when :c
           info = pry_doc_info
           info.docstring if info
-        when :rbx
-          strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
         when :ruby
-          if pry_method?
+          if Helpers::BaseHelpers.rbx? && core?
+            strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
+          elsif pry_method?
             raise CommandError, "Can't view doc for a REPL-defined method."
           else
             strip_leading_hash_and_whitespace_from_ruby_comments(@method.comment)
@@ -206,14 +276,9 @@ class Pry
     end
 
     # @return [Symbol] The source type of the method. The options are
-    #   `:ruby` for ordinary Ruby methods, `:c` for methods written in
-    #   C, or `:rbx` for Rubinius core methods written in Ruby.
+    #   `:ruby` for Ruby methods or `:c` for methods written in C.
     def source_type
-      if Helpers::BaseHelpers.rbx?
-        if core? then :rbx else :ruby end
-      else
-        if source_location.nil? then :c else :ruby end
-      end
+      source_location.nil? ? :c : :ruby
     end
 
     # @return [String, nil] The name of the file the method is defined in, or
@@ -235,6 +300,12 @@ class Pry
       source_location.nil? ? nil : source_location.last
     end
 
+    # @return [Range, nil] The range of lines in `source_file` which contain
+    #    the method's definition, or `nil` if that information is unavailable.
+    def source_range
+      source_location.nil? ? nil : (source_line)...(source_line + source.lines.count)
+    end
+
     # @return [Symbol] The visibility of the method. May be `:public`,
     #   `:protected`, or `:private`.
     def visibility
@@ -286,43 +357,11 @@ class Pry
       Pry::Method.new(sup) if sup
     end
 
-    # @return [Symbol, nil] The original name the method was defined under,
+    # @return [String, nil] The original name the method was defined under,
     #   before any aliasing, or `nil` if it can't be determined.
     def original_name
       return nil if source_type != :ruby
-
-      first_line = source.lines.first
-      return nil if first_line.strip !~ /^def /
-
-      if RUBY_VERSION =~ /^1\.9/ && RUBY_ENGINE == "ruby"
-        require 'ripper'
-
-        # Ripper is ok with an extraneous end, so we don't need to worry about
-        # whether it's a one-liner.
-        tree = Ripper::SexpBuilder.new(first_line + ";end").parse
-
-        name = tree.flatten(2).each do |lst|
-          break lst[1] if lst[0] == :@ident
-        end
-
-        name.is_a?(String) ? name : nil
-      else
-        require 'ruby_parser'
-
-        # RubyParser breaks if there's an extra end, so we'll just rescue
-        # and try again.
-        tree = begin
-          RubyParser.new.parse(first_line + ";end")
-        rescue Racc::ParseError
-          RubyParser.new.parse(first_line)
-        end
-
-        name = tree.each_cons(2) do |a, b|
-          break a if b.is_a?(Array) && b.first == :args
-        end
-
-        name.is_a?(Symbol) ? name.to_s : nil
-      end
+      method_name_from_first_line(source.lines.first)
     end
 
     # @return [Boolean] Was the method defined outside a source file?
@@ -409,5 +448,65 @@ class Pry
         end
         next_owner.instance_method(name) rescue nil
       end
+
+      # @param [String] first_ln The first line of a method definition.
+      # @return [String, nil]
+      def method_name_from_first_line(first_ln)
+        return nil if first_ln.strip !~ /^def /
+
+        tokens = CodeRay.scan(first_ln, :ruby)
+        tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens)
+        tokens.each_cons(2) do |t1, t2|
+          if t2.last == :method || t2.last == :ident && t1 == [".", :operator]
+            return t2.first
+          end
+        end
+
+        nil
+      end
+
+    # A Disowned Method is one that's been removed from the class on which it was defined.
+    #
+    # e.g.
+    # class C
+    #   def foo
+    #     C.send(:undefine_method, :foo)
+    #     Pry::Method.from_binding(binding)
+    #   end
+    # end
+    #
+    # In this case we assume that the "owner" is the singleton class of the receiver.
+    #
+    # This occurs mainly in Sinatra applications.
+    class Disowned < Method
+      attr_reader :receiver, :name
+
+      # Create a new Disowned method.
+      #
+      # @param [Object] receiver
+      # @param [String] method_name
+      def initialize(*args)
+        @receiver, @name = *args
+      end
+
+      # Is the method undefined? (aka `Disowned`)
+      # @return [Boolean] true
+      def undefined?
+        true
+      end
+
+      # Get the hypothesized owner of the method.
+      #
+      # @return [Object]
+      def owner
+        class << receiver; self; end
+      end
+
+      # Raise a more useful error message instead of trying to forward to nil.
+      def method_missing(meth_name, *args, &block)
+        raise "Cannot call '#{meth_name}' on an undef'd method." if method(:name).respond_to?(meth_name)
+        Object.instance_method(:method_missing).bind(self).call(meth_name, *args, &block)
+      end
+    end
   end
 end

data/lib/pry/plugins.rb

@@ -9,7 +9,7 @@ class Pry
       end
 
       def method_missing(*args)
-        $stderr.puts "Warning: The plugin '#{@name}' was not found! (no gem found)"
+        warn "Warning: The plugin '#{@name}' was not found! (no gem found)"
       end
     end
 
@@ -32,13 +32,21 @@ class Pry
         self.enabled = true
       end
 
+      # Load the Command line options defined by this plugin (if they exist)
+      def load_cli_options
+        cli_options_file = File.join(spec.full_gem_path, "lib/#{spec.name}/cli.rb")
+        require cli_options_file if File.exists?(cli_options_file)
+      end
       # Activate the plugin (require the gem - enables/loads the
-      # plugin immediately at point of call, even if plugin is disabled)
+      # plugin immediately at point of call, even if plugin is
+      # disabled)
+      # Does not reload plugin if it's already active.
       def activate!
         begin
           require gem_name if !active?
-        rescue LoadError
-          $stderr.puts "Warning: The plugin '#{gem_name}' was not found! (gem found but could not be loaded)"
+        rescue LoadError => e
+          warn "Warning: The plugin '#{gem_name}' was not found! (gem found but could not be loaded)"
+          warn e
         end
         self.active = true
         self.enabled = true

data/lib/pry/pry_class.rb

@@ -73,6 +73,30 @@ class Pry
     end
   end
 
+  # Trap interrupts on jruby, and make them behave like MRI so we can
+  # catch them.
+  def self.load_traps
+    trap('INT'){ raise Interrupt }
+  end
+
+  # Do basic setup for initial session.
+  # Including: loading .pryrc, loading plugins, loading requires, and
+  # loading history.
+  def self.initial_session_setup
+
+    return if !initial_session?
+
+    # 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_plugins if Pry.config.should_load_plugins
+    load_requires if Pry.config.should_load_requires
+    load_history if Pry.config.history.should_load
+    load_traps if Pry.config.should_trap_interrupts
+
+    @initial_session = false
+  end
+
   # Start a Pry REPL.
   # This method also loads the files specified in `Pry::RC_FILES` the
   # first time it is invoked.
@@ -82,19 +106,34 @@ class Pry
   # @example
   #   Pry.start(Object.new, :input => MyInput.new)
   def self.start(target=TOPLEVEL_BINDING, options={})
-    if initial_session?
-      # note these have to be loaded here rather than in pry_instance as
-      # we only want them loaded once per entire Pry lifetime, not
-      # 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_requires if Pry.config.should_load_requires
-      load_history if Pry.config.history.should_load
-
-      @initial_session = false
+    target = Pry.binding_for(target)
+    initial_session_setup
+
+    # create the Pry instance to manage the session
+    pry_instance = new(options)
+
+    # save backtrace
+    pry_instance.backtrace = caller
+
+    # if Pry was started via binding.pry, elide that from the backtrace.
+    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
+                           )
+
+    if !pry_instance.binding_stack.empty?
+      head = pry_instance.binding_stack.pop
+    else
+      head = target
     end
 
-    new(options).repl(target)
+    # Enter the matrix
+    pry_instance.repl(head)
   end
 
   # An inspector that clips the output to `max_length` chars.
@@ -120,17 +159,12 @@ class Pry
 
   # Load Readline history if required.
   def self.load_history
-    Pry.history.load(history_file) if File.exists?(history_file)
+    Pry.history.load
   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)
+    Pry.history.save
   end
 
   # @return [Boolean] Whether this is the first time a Pry session has
@@ -165,14 +199,19 @@ class Pry
 
     output = options[:show_output] ? options[:output] : StringIO.new
 
-    Pry.new(:output => output, :input => StringIO.new(command_string), :commands => options[:commands], :prompt => proc {""}, :hooks => {}).rep(options[:context])
+    Pry.new(:output => output, :input => StringIO.new(command_string), :commands => options[:commands], :prompt => proc {""}, :hooks => Pry::Hooks.new).rep(options[:context])
   end
 
   def self.default_editor_for_platform
-    if RUBY_PLATFORM =~ /mswin|mingw/
-      ENV['VISUAL'] || ENV['EDITOR'] || "notepad"
+    return ENV['VISUAL'] if ENV['VISUAL'] and not ENV['VISUAL'].empty?
+    return ENV['EDITOR'] if ENV['EDITOR'] and not ENV['EDITOR'].empty?
+
+    if Helpers::BaseHelpers.windows?
+      'notepad'
     else
-      ENV['VISUAL'] || ENV['EDITOR'] || "nano"
+      %w(editor nano vi).detect do |editor|
+        system("which #{editor} > /dev/null 2>&1")
+      end
     end
   end
 
@@ -183,22 +222,26 @@ class Pry
     config.prompt = DEFAULT_PROMPT
     config.print = DEFAULT_PRINT
     config.exception_handler = DEFAULT_EXCEPTION_HANDLER
-    config.exception_window_size = 5
     config.exception_whitelist = DEFAULT_EXCEPTION_WHITELIST
+    config.default_window_size = 5
     config.hooks = DEFAULT_HOOKS
     config.input_stack = []
-    config.color = Pry::Helpers::BaseHelpers.use_ansi_codes?
+    config.color = Helpers::BaseHelpers.use_ansi_codes?
     config.pager = true
     config.system = DEFAULT_SYSTEM
     config.editor = default_editor_for_platform
     config.should_load_rc = true
+    config.should_trap_interrupts = Helpers::BaseHelpers.jruby?
     config.disable_auto_reload = false
     config.command_prefix = ""
     config.auto_indent = true
     config.correct_indent = true
+    config.collision_warning = false
+
+    config.gist ||= OpenStruct.new
+    config.gist.inspecter = proc(&:pretty_inspect)
 
-    config.plugins ||= OpenStruct.new
-    config.plugins.enabled = true
+    config.should_load_plugins = true
 
     config.requires ||= []
     config.should_load_requires = true