pry 0.10.pre.1-i386-mingw32 → 0.10.0.pre3-i386-mingw32

data/lib/pry/history_array.rb

@@ -1,6 +1,6 @@
 class Pry
   # A history array is an array to which you can only add elements. Older
-  # entries are removed progressively, so that the aray never contains more than
+  # entries are removed progressively, so that the array never contains more than
   # N elements.
   #
   # History arrays are used by Pry to store the output of the last commands.
@@ -89,6 +89,16 @@ class Pry
       ((@count - size)...@count).map { |n| @hash[n] }
     end
 
+    # Returns [Hash] copy of the internal @hash history
+    def to_h
+      @hash.dup
+    end
+
+    def pop!
+      @hash.delete @count - 1
+      @count -= 1
+    end
+
     def inspect
       "#<#{self.class} size=#{size} first=#{@count - size} max_size=#{max_size}>"
     end

data/lib/pry/hooks.rb

@@ -18,11 +18,11 @@ class Pry
     # @param [Hash] hash The hash to convert to `Pry::Hooks`.
     # @return [Pry::Hooks] The resulting `Pry::Hooks` instance.
     def self.from_hash(hash)
+      return hash if hash.instance_of?(self)
       instance = new
       hash.each do |k, v|
         instance.add_hook(k, nil, v)
       end
-
       instance
     end
 
@@ -49,22 +49,6 @@ class Pry
       @errors ||= []
     end
 
-    # FIXME:
-    # This is a hack to alert people of the new API.
-    def [](event_name)
-      warn "`Pry.hooks[]` is deprecated! Please use the new `Pry::Hooks` API! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
-
-      get_hook(event_name, nil)
-    end
-
-    # FIXME:
-    # This is a hack to alert people of the new API.
-    def []=(event_name, callable)
-      warn "`Pry.hooks[]=` is deprecated! Please use the new `Pry::Hooks` API! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
-
-      add_hook(event_name, nil, callable)
-    end
-
     # Destructively merge the contents of two `Pry:Hooks` instances.
     # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
     # @return [Pry:Hooks] Returns the receiver.
@@ -146,18 +130,14 @@ class Pry
     def exec_hook(event_name, *args, &block)
       @hooks[event_name] ||= []
 
-      # silence warnings to get rid of 1.8's "warning: multiple values
-      # for a block parameter" warnings
-      Pry::Helpers::BaseHelpers.silence_warnings do
-        @hooks[event_name].map do |hook_name, callable|
-          begin
-            callable.call(*args, &block)
-          rescue RescuableException => e
-            errors << e
-            e
-          end
-        end.last
-      end
+      @hooks[event_name].map do |hook_name, callable|
+        begin
+          callable.call(*args, &block)
+        rescue RescuableException => e
+          errors << e
+          e
+        end
+      end.last
     end
 
     # Return the number of hook functions registered for the `event_name` event.
@@ -244,9 +224,7 @@ class Pry
     # @param [Symbol] hook_name Name of the hook.
     # @return [Boolean] Whether the hook by the name `hook_name`
     def hook_exists?(event_name, hook_name)
-      !!@hooks[event_name].find { |name, _| name == hook_name }
+      !!(@hooks[event_name] && @hooks[event_name].find { |name, _| name == hook_name })
     end
-    private :hook_exists?
-
   end
 end

data/lib/pry/indent.rb

@@ -1,12 +1,6 @@
 require 'coderay'
 
 class Pry
-  # Load io-console if possible, so that we can use $stdout.winsize.
-  begin
-    require 'io/console'
-  rescue LoadError
-  end
-
   ##
   # Pry::Indent is a class that can be used to indent a number of lines
   # containing Ruby code similar as to how IRB does it (but better). The class
@@ -17,9 +11,15 @@ class Pry
   class Indent
     include Helpers::BaseHelpers
 
-    # String containing the spaces to be inserted before the next line.
+    # Raised if {#module_nesting} would not work.
+    class UnparseableNestingError < StandardError; end
+
+    # @return [String] String containing the spaces to be inserted before the next line.
     attr_reader :indent_level
 
+    # @return [Array<String>] The stack of open tokens.
+    attr_reader :stack
+
     # The amount of spaces to insert for each indent level.
     SPACES = '  '
 
@@ -48,6 +48,9 @@ class Pry
     # a single-line.
     SINGLELINE_TOKENS = %w(if while until unless rescue)
 
+    # Which tokens can be followed by an optional "do" keyword.
+    OPTIONAL_DO_TOKENS = %w(for while until)
+
     # 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.
@@ -70,6 +73,32 @@ class Pry
     # don't affect the surrounding code.
     MIDWAY_TOKENS = %w(when else elsif ensure rescue)
 
+    # Clean the indentation of a fragment of ruby.
+    #
+    # @param [String] str
+    # @return [String]
+    def self.indent(str)
+      new.indent(str)
+    end
+
+    # Get the module nesting at the given point in the given string.
+    #
+    # NOTE If the line specified contains a method definition, then the nesting
+    # at the start of the method definition is used. Otherwise the nesting from
+    # the end of the line is used.
+    #
+    # @param [String] str The ruby code to analyze
+    # @param [Fixnum] line_number The line number (starting from 1)
+    # @return [Array<String>]
+    def self.nesting_at(str, line_number)
+      indent = new
+      lines = str.split("\n")
+      n = line_number - 1
+      to_indent = lines[0...n] << (lines[n] || "").split("def").first(1)
+      indent.indent(to_indent.join("\n") << "\n")
+      indent.module_nesting
+    end
+
     def initialize
       reset
     end
@@ -81,6 +110,8 @@ class Pry
       @heredoc_queue = []
       @close_heredocs = {}
       @string_start = nil
+      @awaiting_class = false
+      @module_nesting = []
       self
     end
 
@@ -126,7 +157,6 @@ class Pry
         new_prefix = prefix + SPACES * after
 
         line = prefix + line.lstrip unless previously_in_string
-        line = line.rstrip + "\n"   unless in_string?
 
         output += line
 
@@ -135,7 +165,7 @@ class Pry
 
       @indent_level = prefix
 
-      return output.gsub(/\s+$/, '')
+      return output
     end
 
     # Get the indentation for the start of the next line.
@@ -189,7 +219,9 @@ class Pry
         last_token, last_kind = token, kind unless kind == :space
         next if IGNORE_TOKENS.include?(kind)
 
-        seen_for_at << add_after if token == "for"
+        track_module_nesting(token, kind)
+
+        seen_for_at << add_after if OPTIONAL_DO_TOKENS.include?(token)
 
         if kind == :delimiter
           track_delimiter(token)
@@ -197,7 +229,8 @@ class Pry
           @stack << token
           add_after += 1
         elsif token == OPEN_TOKENS[@stack.last]
-          @stack.pop
+          popped = @stack.pop
+          track_module_nesting_end(popped)
           if add_after == 0
             remove_before += 1
           else
@@ -279,6 +312,68 @@ class Pry
       "puts #{open_delimiters.join(", ")}"
     end
 
+    # Update the internal state relating to module nesting.
+    #
+    # It's responsible for adding to the @module_nesting array, which looks
+    # something like:
+    #
+    # [ ["class", "Foo"], ["module", "Bar::Baz"], ["class <<", "self"] ]
+    #
+    # A nil value in the @module_nesting array happens in two places: either
+    # when @awaiting_class is true and we're still waiting for the string to
+    # fill that space, or when a parse was rejected.
+    #
+    # At the moment this function is quite restricted about what formats it will
+    # parse, for example we disallow expressions after the class keyword. This
+    # could maybe be improved in the future.
+    #
+    # @param [String] token  a token from Coderay
+    # @param [Symbol] kind  the kind of that token
+    def track_module_nesting(token, kind)
+      if kind == :keyword && (token == "class" || token == "module")
+        @module_nesting << [token, nil]
+        @awaiting_class = true
+      elsif @awaiting_class
+        if kind == :operator && token == "<<" && @module_nesting.last[0] == "class"
+          @module_nesting.last[0] = "class <<"
+          @awaiting_class = true
+        elsif kind == :class && token =~ /\A(self|[A-Z:][A-Za-z0-9_:]*)\z/
+          @module_nesting.last[1] = token if kind == :class
+          @awaiting_class = false
+        else
+          # leave @module_nesting[-1]
+          @awaiting_class = false
+        end
+      end
+    end
+
+    # Update the internal state relating to module nesting on 'end'.
+    #
+    # If the current 'end' pairs up with a class or a module then we should
+    # pop an array off of @module_nesting
+    #
+    # @param [String] token  a token from Coderay
+    # @param [Symbol] kind  the kind of that token
+    def track_module_nesting_end(token, kind=:keyword)
+      if kind == :keyword && (token == "class" || token == "module")
+        @module_nesting.pop
+      end
+    end
+
+    # Return a list of strings which can be used to re-construct the Module.nesting at
+    # the current point in the file.
+    #
+    # Returns nil if the syntax of the file was not recognizable.
+    #
+    # @return [Array<String>]
+    def module_nesting
+      @module_nesting.map do |(kind, token)|
+        raise UnparseableNestingError, @module_nesting.inspect if token.nil?
+
+        "#{kind} #{token}"
+      end
+    end
+
     # Return a string which, when printed, will rewrite the previous line with
     # the correct indentation. Mostly useful for fixing 'end'.
     #
@@ -288,13 +383,14 @@ class Pry
     #   the difference in length between the old line and the new one).
     # @return [String]
     def correct_indentation(prompt, code, overhang=0)
-      full_line = prompt + code
+      prompt = prompt.delete("\001\002")
+      line_to_measure = Pry::Helpers::Text.strip_color(prompt) << code
       whitespace = ' ' * overhang
 
-      _, cols = screen_size
+      _, cols = Terminal.screen_size
 
       cols = cols.to_i
-      lines = cols != 0 ? (full_line.length / cols + 1) : 1
+      lines = (cols != 0 ? (line_to_measure.length / cols + 1) : 1).to_i
 
       if Pry::Helpers::BaseHelpers.windows_ansi?
         move_up   = "\e[#{lines}F"
@@ -306,29 +402,5 @@ class Pry
 
       "#{move_up}#{prompt}#{colorize_code(code)}#{whitespace}#{move_down}"
     end
-
-    # 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
-      [
-         # io/console adds a winsize method to IO streams.
-         $stdout.tty? && $stdout.respond_to?(:winsize) && $stdout.winsize,
-
-         # Some readlines also provides get_screen_size.
-         Readline.respond_to?(:get_screen_size) && Readline.get_screen_size,
-
-         # Otherwise try to use the environment (this may be out of date due
-         # to window resizing, but it's better than nothing).
-         [ENV["ROWS"], ENV["COLUMNS"],
-
-         # If the user is running within ansicon, then use the screen size
-         # that it reports (same caveats apply as with ROWS and COLUMNS)
-         ENV['ANSICON'] =~ /\((.*)x(.*)\)/ && [$2, $1]
-        ]
-      ].detect do |(_, cols)|
-        cols.to_i > 0
-      end
-    end
   end
 end

data/lib/pry/input_completer.rb

@@ -0,0 +1,242 @@
+# taken from irb
+# Implements tab completion for Readline in Pry
+class Pry::InputCompleter
+  NUMERIC_REGEXP            = /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
+  ARRAY_REGEXP              = /^([^\]]*\])\.([^.]*)$/
+  SYMBOL_REGEXP             = /^(:[^:.]*)$/
+  SYMBOL_METHOD_CALL_REGEXP = /^(:[^:.]+)\.([^.]*)$/
+  REGEX_REGEXP              = /^(\/[^\/]*\/)\.([^.]*)$/
+  PROC_OR_HASH_REGEXP       = /^([^\}]*\})\.([^.]*)$/
+  TOPLEVEL_LOOKUP_REGEXP    = /^::([A-Z][^:\.\(]*)$/
+  CONSTANT_REGEXP           = /^([A-Z][A-Za-z0-9]*)$/
+  CONSTANT_OR_METHOD_REGEXP = /^([A-Z].*)::([^:.]*)$/
+  HEX_REGEXP                = /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
+  GLOBALVARIABLE_REGEXP     = /^(\$[^.]*)$/
+  VARIABLE_REGEXP           = /^([^."].*)\.([^.]*)$/
+
+  ReservedWords = [
+                   "BEGIN", "END",
+                   "alias", "and",
+                   "begin", "break",
+                   "case", "class",
+                   "def", "defined", "do",
+                   "else", "elsif", "end", "ensure",
+                   "false", "for",
+                   "if", "in",
+                   "module",
+                   "next", "nil", "not",
+                   "or",
+                   "redo", "rescue", "retry", "return",
+                   "self", "super",
+                   "then", "true",
+                   "undef", "unless", "until",
+                   "when", "while",
+                   "yield" ]
+
+  Operators = [
+               "%", "&", "*", "**", "+",  "-",  "/",
+               "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
+               "[]", "[]=", "^", "!", "!=", "!~"
+              ]
+
+  WORD_ESCAPE_STR = " \t\n\"\\'`><=;|&{("
+
+  def initialize(input, pry = nil)
+    @pry = pry
+    @input = input
+    @input.basic_word_break_characters = WORD_ESCAPE_STR if @input.respond_to?(:basic_word_break_characters=)
+    @input.completion_append_character = nil if @input.respond_to?(:completion_append_character=)
+  end
+
+  #
+  # Return a new completion proc for use by Readline.
+  #
+  def call(str, options = {})
+    custom_completions = options[:custom_completions] || []
+    # if there are multiple contexts e.g. cd 1/2/3
+    # get new target for 1/2 and find candidates for 3
+    path, input = build_path(str)
+
+    if path.call.empty?
+      target = options[:target]
+    else
+      # Assume the user is tab-completing the 'cd' command
+      begin
+        target = Pry::ObjectPath.new(path.call, @pry.binding_stack).resolve.last
+      # but if that doesn't work, assume they're doing division with no spaces
+      rescue Pry::CommandError
+        target = options[:target]
+      end
+    end
+
+    begin
+      bind = target
+      # Complete stdlib symbols
+      case input
+      when REGEX_REGEXP # Regexp
+        receiver = $1
+        message = Regexp.quote($2)
+        candidates = Regexp.instance_methods.collect(&:to_s)
+        select_message(path, receiver, message, candidates)
+      when ARRAY_REGEXP # Array
+        receiver = $1
+        message = Regexp.quote($2)
+        candidates = Array.instance_methods.collect(&:to_s)
+        select_message(path, receiver, message, candidates)
+      when PROC_OR_HASH_REGEXP # Proc or Hash
+        receiver = $1
+        message = Regexp.quote($2)
+        candidates = Proc.instance_methods.collect(&:to_s)
+        candidates |= Hash.instance_methods.collect(&:to_s)
+        select_message(path, receiver, message, candidates)
+      when SYMBOL_REGEXP # Symbol
+        if Symbol.respond_to?(:all_symbols)
+          sym        = Regexp.quote($1)
+          candidates = Symbol.all_symbols.collect{|s| ":" << s.id2name}
+          candidates.grep(/^#{sym}/)
+        else
+          []
+        end
+      when TOPLEVEL_LOOKUP_REGEXP # Absolute Constant or class methods
+        receiver = $1
+        candidates = Object.constants.collect(&:to_s)
+        candidates.grep(/^#{receiver}/).collect{|e| "::" << e}
+      when CONSTANT_REGEXP # Constant
+        message = $1
+        begin
+          context = target.eval("self")
+          context = context.class unless context.respond_to? :constants
+                                    candidates = context.constants.collect(&:to_s)
+                                  rescue
+                                    candidates = []
+                                  end
+          candidates = candidates.grep(/^#{message}/).collect(&path)
+        when CONSTANT_OR_METHOD_REGEXP # Constant or class methods
+          receiver = $1
+          message = Regexp.quote($2)
+          begin
+            candidates = eval("#{receiver}.constants.collect(&:to_s)", bind)
+            candidates |= eval("#{receiver}.methods.collect(&:to_s)", bind)
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          candidates.grep(/^#{message}/).collect{|e| receiver << "::" << e}
+        when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
+          receiver = $1
+          message = Regexp.quote($2)
+          candidates = Symbol.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when NUMERIC_REGEXP
+          # Numeric
+          receiver = $1
+          message = Regexp.quote($5)
+          begin
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+        when HEX_REGEXP
+          # Numeric(0xFFFF)
+          receiver = $1
+          message = Regexp.quote($2)
+          begin
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+        when GLOBALVARIABLE_REGEXP # global
+          regmessage = Regexp.new(Regexp.quote($1))
+          candidates = global_variables.collect(&:to_s).grep(regmessage)
+        when VARIABLE_REGEXP # variable
+          receiver = $1
+          message = Regexp.quote($2)
+
+          gv = eval("global_variables", bind).collect(&:to_s)
+          lv = eval("local_variables", bind).collect(&:to_s)
+          cv = eval("self.class.constants", bind).collect(&:to_s)
+
+          if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
+            # foo.func and foo is local var. OR
+            # Foo::Bar.func
+            begin
+              candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
+            rescue Pry::RescuableException
+              candidates = []
+            end
+          else
+            # func1.func2
+            candidates = []
+            ObjectSpace.each_object(Module){|m|
+              begin
+                name = m.name.to_s
+              rescue Pry::RescuableException
+                name = ""
+              end
+              next if name != "IRB::Context" and
+              /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+
+              # jruby doesn't always provide #instance_methods() on each
+              # object.
+              if m.respond_to?(:instance_methods)
+                candidates.concat m.instance_methods(false).collect(&:to_s)
+              end
+            }
+            candidates.sort!
+            candidates.uniq!
+          end
+          select_message(path, receiver, message, candidates)
+        when /^\.([^.]*)$/
+          # Unknown(maybe String)
+          receiver = ""
+          message = Regexp.quote($1)
+          candidates = String.instance_methods(true).collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        else
+          candidates = eval(
+                            "methods | private_methods | local_variables | " \
+                            "self.class.constants | instance_variables",
+                            bind
+                            ).collect(&:to_s)
+
+          if eval("respond_to?(:class_variables)", bind)
+            candidates += eval("class_variables", bind).collect(&:to_s)
+          end
+          candidates = (candidates|ReservedWords|custom_completions).grep(/^#{Regexp.quote(input)}/)
+          candidates.collect(&path)
+        end
+      rescue Pry::RescuableException
+        []
+      end
+    end
+
+    def select_message(path, receiver, message, candidates)
+      candidates.grep(/^#{message}/).collect { |e|
+        case e
+        when /^[a-zA-Z_]/
+          path.call(receiver + "." << e)
+        when /^[0-9]/
+        when *Operators
+          #receiver + " " << e
+        end
+      }.compact
+    end
+
+    # build_path seperates the input into two parts: path and input.
+    # input is the partial string that should be completed
+    # path is a proc that takes an input and builds a full path.
+    def build_path(input)
+      # check to see if the input is a regex
+      return proc {|i| i.to_s }, input if input[/\/\./]
+      trailing_slash = input.end_with?('/')
+      contexts = input.chomp('/').split(/\//)
+      input = contexts[-1]
+      path = proc do |i|
+        p = contexts[0..-2].push(i).join('/')
+        p += '/' if trailing_slash && !i.nil?
+        p
+      end
+      return path, input
+    end
+end