pry 0.9.11.4 → 0.9.12pre1

data/lib/pry/method/weird_method_locator.rb

@@ -0,0 +1,186 @@
+class Pry
+  class Method
+
+    # This class is responsible for locating the *real* `Pry::Method`
+    # object captured by a binding.
+    #
+    # Given a `Binding` from inside a method and a 'seed' Pry::Method object,
+    # there are primarily two situations where the seed method doesn't match
+    # the Binding:
+    # 1. The Pry::Method is from a subclass 2. The Pry::Method represents a method of the same name
+    # while the original was renamed to something else. For 1. we
+    # search vertically up the inheritance chain,
+    # and for 2. we search laterally along the object's method table.
+    #
+    # When we locate the method that matches the Binding we wrap it in
+    # Pry::Method and return it, or return nil if we fail.
+    class WeirdMethodLocator
+      class << self
+
+        # Whether the given method object matches the associated binding.
+        # If the method object does not match the binding, then it's
+        # most likely not the method captured by the binding, and we
+        # must commence a search.
+        #
+        # @param [Pry::Method] method
+        # @param [Binding] b
+        # @return [Boolean]
+        def normal_method?(method, b)
+          method && (method.source_file && method.source_range rescue false) &&
+          File.expand_path(method.source_file) == File.expand_path(b.eval('__FILE__')) &&
+          method.source_range.include?(b.eval('__LINE__'))
+        end
+
+        def weird_method?(method, b)
+          !normal_method?(method, b)
+        end
+      end
+
+      attr_accessor :method
+      attr_accessor :target
+
+      # @param [Pry::Method] method The seed method.
+      # @param [Binding] target The Binding that captures the method
+      #   we want to locate.
+      def initialize(method, target)
+        @method, @target = method, target
+      end
+
+      # @return [Pry::Method, nil] The Pry::Method that matches the
+      #   given binding.
+      def get_method
+        find_method_in_superclass || find_renamed_method
+      end
+
+      # @return [Boolean] Whether the Pry::Method is unrecoverable
+      #   This usually happens when the method captured by the Binding
+      #   has been subsequently deleted.
+      def lost_method?
+        !!(get_method.nil? && renamed_method_source_location)
+      end
+
+      private
+
+      def normal_method?(method)
+        self.class.normal_method?(method, target)
+      end
+
+      def target_self
+        target.eval('self')
+      end
+
+      def target_file
+        pry_file? ? target.eval('__FILE__') : File.expand_path(target.eval('__FILE__'))
+      end
+
+      def target_line
+        target.eval('__LINE__')
+      end
+
+      def pry_file?
+        Pry.eval_path == target.eval('__FILE__')
+      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.
+      #
+      # @return [Pry::Method, nil] The Pry::Method representing the
+      #   superclass method.
+      def find_method_in_superclass
+        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 normal_method?(guess)
+            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)
+        nil
+      end
+
+      # This is the case where the name of a method has changed
+      # (via alias_method) so we locate the Method object for the
+      # renamed method.
+      #
+      # @return [Pry::Method, nil] The Pry::Method representing the
+      #   renamed method
+      def find_renamed_method
+        return if !valid_file?(target_file)
+        alias_name = all_methods_for(target_self).find do |v|
+          expanded_source_location(target_self.method(v).source_location) == renamed_method_source_location
+        end
+
+        alias_name && Pry::Method(target_self.method(alias_name))
+      end
+
+      def expanded_source_location(sl)
+        return if !sl
+
+        if pry_file?
+          sl
+        else
+          [File.expand_path(sl.first), sl.last]
+        end
+      end
+
+      # Use static analysis to locate the start of the method definition.
+      # We have the `__FILE__` and `__LINE__` from the binding and the
+      # original name of the method so we search up until we find a
+      # def/define_method, etc defining a method of the appropriate name.
+      #
+      # @return [Array<String, Fixnum>] The `source_location` of the
+      #   renamed method
+      def renamed_method_source_location
+        return @original_method_source_location if defined?(@original_method_source_location)
+
+        source_index = lines_for_file(target_file)[0..(target_line - 1)].rindex do |v|
+          Pry::Method.method_definition?(method.name, v)
+        end
+
+        @original_method_source_location = source_index &&
+          [target_file, index_to_line_number(source_index)]
+      end
+
+      def index_to_line_number(index)
+        # Pry.line_buffer is 0-indexed
+        pry_file? ? index : index + 1
+      end
+
+      def valid_file?(file)
+        File.exists?(file) || Pry.eval_path == file
+      end
+
+      def lines_for_file(file)
+        @lines_for_file ||= {}
+        @lines_for_file[file] ||= if Pry.eval_path == file
+                                    Pry.line_buffer
+                                  else
+                                    File.readlines(file)
+                                  end
+      end
+
+      def all_methods_for(obj)
+        obj.public_methods(false) +
+          obj.private_methods(false) +
+          obj.protected_methods(false)
+      end
+    end
+  end
+end

data/lib/pry/module_candidate.rb

@@ -52,8 +52,8 @@ class Pry
       # @return [String] The source for the candidate, i.e the
       #   complete module/class definition.
       def source
+        return nil if file.nil?
         return @source if @source
-        raise CommandError, "Could not locate source for #{wrapped}!" if file.nil?
 
         @source = strip_leading_whitespace(Pry::Code.from_file(file).expression_at(line, number_of_lines_in_first_chunk))
       end
@@ -61,10 +61,10 @@ class Pry
       # @raise [Pry::CommandError] If documentation cannot be found.
       # @return [String] The documentation for the candidate.
       def doc
+        return nil if file.nil?
         return @doc if @doc
-        raise CommandError, "Could not locate doc for #{wrapped}!" if file.nil?
 
-        @doc = strip_leading_hash_and_whitespace_from_ruby_comments(Pry::Code.from_file(file).comment_describing(line))
+        @doc = get_comment_content(Pry::Code.from_file(file).comment_describing(line))
       end
 
       # @return [Array, nil] A `[String, Fixnum]` pair representing the

data/lib/pry/pager.rb

@@ -12,8 +12,11 @@ class Pry::Pager
     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
+      if no_pager || Pry::Helpers::BaseHelpers.jruby?
+        SimplePager.new(text).page
+      else
+        SystemPager.new(text).page
+      end
     when :simple
       SimplePager.new(text).page
     when :system
@@ -24,12 +27,8 @@ class Pry::Pager
   end
 
   def self.page_size
-    @page_size ||= begin
-      require 'io/console'
-      $stdout.winsize.first
-    rescue LoadError
-      27
-    end
+    rows = Pry::Terminal.screen_size
+    @page_size ||= (rows && rows.first || 27)
   end
 
   def initialize(text)
@@ -38,11 +37,14 @@ class Pry::Pager
 
   class SimplePager < Pry::Pager
     def page
+      # The pager size minus the number of lines used by the simple pager info bar.
+      page_size = Pry::Pager.page_size - 3
       text_array = @text.lines.to_a
-      text_array.each_slice(Pry::Pager.page_size) do |chunk|
+
+      text_array.each_slice(page_size) do |chunk|
         puts chunk.join
-        break if chunk.size < Pry::Pager.page_size
-        if text_array.size > Pry::Pager.page_size
+        break if chunk.size < page_size
+        if text_array.size > page_size
           puts "\n<page break> --- Press enter to continue ( q<enter> to break ) --- <page break>"
           break if $stdin.gets.chomp == "q"
         end

data/lib/pry/pry_class.rb

@@ -263,9 +263,16 @@ class Pry
 
   def self.auto_resize!
     trap :WINCH do
-      size = `stty size`.split(/\s+/).map &:to_i
-      Readline.set_screen_size *size
-      Readline.refresh_line
+      begin
+        Readline.set_screen_size *Terminal.size!
+      rescue => e
+        warn "\nPry.auto_resize!'s Readline.set_screen_size failed: #{e}"
+      end
+      begin
+        Readline.refresh_line
+      rescue => e
+        warn "\nPry.auto_resize!'s Readline.refresh_line failed: #{e}"
+      end
     end
   end
 

data/lib/pry/terminal.rb

@@ -0,0 +1,73 @@
+class Pry::Terminal
+  class << self
+    # Return a pair of [rows, columns] which gives the size of the window.
+    #
+    # If the window size cannot be determined, return nil.
+    def screen_size
+      rows, cols = actual_screen_size
+      if rows && cols
+        [rows.to_i, cols.to_i]
+      else
+        nil
+      end
+    end
+
+    # Return a screen size or a default if that fails.
+    def size! default = [25, 80]
+      screen_size || default
+    end
+
+    # Return a screen width or the default if that fails.
+    def width! default = 80
+      size![1]
+    end
+
+    def actual_screen_size
+      # The best way, if possible (requires non-jruby ≥1.9 or io-console gem)
+      screen_size_according_to_io_console or
+        # Fall back to the old standby, though it might be stale:
+        screen_size_according_to_env or
+        # Fall further back, though this one is also out of date without something
+        # calling Readline.set_screen_size
+        screen_size_according_to_readline or
+        # Windows users can otherwise run ansicon and get a decent answer:
+        screen_size_according_to_ansicon_env
+    end
+
+    def screen_size_according_to_io_console
+      return if Pry::Helpers::BaseHelpers.jruby?
+      require 'io/console'
+      $stdout.winsize if $stdout.tty? and $stdout.respond_to?(:winsize)
+    rescue LoadError
+      # They're probably on 1.8 without the io-console gem. We'll keep trying.
+    end
+
+    def screen_size_according_to_env
+      size = [ENV['LINES'] || ENV['ROWS'], ENV['COLUMNS']]
+      size if nonzero_column?(size)
+    end
+
+    def screen_size_according_to_readline
+      if Readline.respond_to?(:get_screen_size)
+        size = Readline.get_screen_size
+        size if nonzero_column?(size)
+      end
+    rescue Java::JavaLang::NullPointerException
+      # This rescue won't happen on jrubies later than:
+      #     https://github.com/jruby/jruby/pull/436
+      nil
+    end
+
+    def screen_size_according_to_ansicon_env
+      return unless ENV['ANSICON'] =~ /\((.*)x(.*)\)/
+      size = [$2, $1]
+      size if nonzero_column?(size)
+    end
+
+    private
+
+    def nonzero_column?(size)
+      size[1].to_i > 0
+    end
+  end
+end

data/lib/pry/version.rb

@@ -1,3 +1,3 @@
 class Pry
-  VERSION = "0.9.11.4"
+  VERSION = "0.9.12pre1"
 end

data/lib/pry/wrapped_module.rb

@@ -65,6 +65,30 @@ class Pry
       @doc = nil
     end
 
+    # Returns an array of the names of the constants accessible in the wrapped
+    # module. This provides a consistent interface between 1.8 and 1.9 and also
+    # avoids the problem of accidentally calling the singleton method
+    # `Module.constants`.
+    # @param [Boolean] inherit (true) Include the names of constants from
+    #   included modules?
+    def constants(inherit = true)
+      method = Module.instance_method(:constants).bind(@wrapped)
+
+      # If we're on 1.8, we have to manually remove ancestors' constants. If
+      # we're on 1.9, though, it's better to use the built-in `inherit` param,
+      # since it doesn't do things like incorrectly remove Pry::Config.
+      if method.arity == 0
+        consts = method.call
+        if !inherit
+          consts -= (@wrapped.ancestors - [@wrapped]).map(&:constants).flatten
+        end
+      else
+        consts = method.call(inherit)
+      end
+
+      consts
+    end
+
     # The prefix that would appear before methods defined on this class.
     #
     # i.e. the "String." or "String#" in String.new and String#initialize.
@@ -205,13 +229,27 @@ class Pry
       @memoized_candidates[rank] ||= Candidate.new(self, rank)
     end
 
-
     # @return [Fixnum] The number of candidate definitions for the
     #   current module.
     def number_of_candidates
       method_candidates.count
     end
 
+    # @note On JRuby 1.9 and higher, in certain conditions, this method chucks
+    #   away its ability to be quick (when there are lots of monkey patches,
+    #   like in Rails). However, it should be efficient enough on other rubies.
+    # @see https://github.com/jruby/jruby/issues/525
+    # @return [Enumerator, Array] on JRuby 1.9 and higher returns Array, on
+    #  other rubies returns Enumerator
+    def candidates
+      enum = generator.new do |y|
+               (0...number_of_candidates).each do |num|
+                 y.yield candidate(num)
+               end
+             end
+      Pry::Helpers::BaseHelpers.jruby_19? ? enum.to_a : enum
+    end
+
     # @return [Boolean] Whether YARD docs are available for this module.
     def yard_docs?
       !!(defined?(YARD) && YARD::Registry.at(name))
@@ -237,6 +275,18 @@ class Pry
 
     private
 
+    # Ruby 1.8 doesn't support `Enumerator` (it's called Generator instead)
+    #
+    # @return [Object] Return the appropriate generator class.
+    def generator
+      @generator ||= if defined?(Enumerator)
+                       Enumerator
+                     else
+                       require 'generator'
+                       Generator
+                     end
+    end
+
     # @return [Pry::WrappedModule::Candidate] The candidate of rank 0,
     #   that is the 'monkey patch' of this module with the highest
     #   number of methods. It is considered the 'canonical' definition

data/spec/command_helpers_spec.rb

@@ -5,5 +5,25 @@ describe Pry::Helpers::CommandHelpers do
     @helper = Pry::Helpers::CommandHelpers
   end
 
-  # FIXME: currently no tests
+  describe "unindent" do
+    it "should remove the same prefix from all lines" do
+      @helper.unindent(" one\n two\n").should == "one\ntwo\n"
+    end
+
+    it "should not be phased by empty lines" do
+      @helper.unindent(" one\n\n two\n").should == "one\n\ntwo\n"
+    end
+
+    it "should only remove a common prefix" do
+      @helper.unindent("  one\n two\n").should == " one\ntwo\n"
+    end
+
+    it "should also remove tabs if present" do
+      @helper.unindent("\tone\n\ttwo\n").should == "one\ntwo\n"
+    end
+
+    it "should ignore lines starting with --" do
+      @helper.unindent(" one\n--\n two\n").should == "one\n--\ntwo\n"
+    end
+  end
 end