pry 0.6.7 → 0.6.8

data/lib/pry/commands.rb

@@ -27,6 +27,44 @@ class Pry
     remove_first_word = lambda do |text|
       text.split.drop(1).join(' ')
     end
+
+    command "whereami", "Show the code context for the session." do
+      file = target.eval('__FILE__')
+      line_num = target.eval('__LINE__')
+      klass = target.eval('self.class')
+
+      meth_name = meth_name_from_binding.call(target)
+      if !meth_name
+        output.puts "Cannot find containing method. Did you remember to use \`binding.pry\` ?"
+        next
+      end
+
+      check_for_dynamically_defined_method.call(file)
+     
+      output.puts "--\nFrom #{file} @ line #{line_num} in #{klass}##{meth_name}:\n--"
+      
+      # This method inspired by http://rubygems.org/gems/ir_b
+      File.open(file).each_with_index do |line, index|
+        line_n = index + 1
+        next unless line_n > (line_num - 6)
+        break if line_n > (line_num + 5)
+        if line_n == line_num
+          code =" =>#{line_n.to_s.rjust(3)}: #{line.chomp}"
+          if Pry.color
+            code = CodeRay.scan(code, :ruby).term
+          end
+          output.puts code
+          code
+        else
+          code = "#{line_n.to_s.rjust(6)}: #{line.chomp}"
+          if Pry.color
+            code = CodeRay.scan(code, :ruby).term
+          end
+          output.puts code
+          code
+        end
+      end
+    end
     
     command "!", "Clear the input buffer. Useful if the parsing process goes wrong and you get stuck in the read loop." do
       output.puts "Input buffer cleared!"
@@ -37,11 +75,12 @@ class Pry
       Pry.start(target)
     end
 
-    command "exit-program", "End the current program. Aliases: quit-program" do
+    command "exit-program", "End the current program. Aliases: quit-program, !!!" do
       exit
     end
 
     alias_command "quit-program", "exit-program", ""
+    alias_command "!!!", "exit-program", ""
 
     command "toggle-color", "Toggle syntax highlighting." do
       Pry.color = !Pry.color
@@ -262,7 +301,7 @@ Shows local and instance variables by default.
         next
       end
 
-      contents = File.read(file_name)
+      contents = File.read(File.expand_path(file_name))
       output.puts contents
       contents
     end
@@ -301,10 +340,10 @@ e.g: eval-file -c self "hello.rb"
       old_constants = Object.constants
       if options[:c]
         target_self = target.eval('self')
-        target.eval(File.read(file_name))
+        target.eval(File.read(File.expand_path(file_name)))
         output.puts "--\nEval'd '#{file_name}' in the `#{target_self}`  context."
       else
-        TOPLEVEL_BINDING.eval(File.read(file_name))
+        TOPLEVEL_BINDING.eval(File.read(File.expand_path(file_name)))
         output.puts "--\nEval'd '#{file_name}' at top-level."
       end
       new_constants = Object.constants - old_constants

data/lib/pry/completion.rb

@@ -1,202 +1,202 @@
-# taken from irb
-
-require "readline"
-
-class Pry
-
-  # Implements tab completion for Readline in Pry
-  module InputCompleter
-    
-    if Readline.respond_to?("basic_word_break_characters=")
-      Readline.basic_word_break_characters= " \t\n\"\\'`><=;|&{("
-    end
-
-    Readline.completion_append_character = nil
-
-    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 = ["%", "&", "*", "**", "+",  "-",  "/",
-                 "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
-                 "[]", "[]=", "^", "!", "!=", "!~"]
-
-    # Return a new completion proc for use by Readline.
-    # @param [Binding] target The current binding context.
-    # @param [Array<String>] commands The array of Pry commands.
-    def self.build_completion_proc(target, commands=[""])
-      proc do |input|
-        bind = target
-
-        case input
-        when /^(\/[^\/]*\/)\.([^.]*)$/
-          # Regexp
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Regexp.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        when /^([^\]]*\])\.([^.]*)$/
-          # Array
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Array.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        when /^([^\}]*\})\.([^.]*)$/
-          # Proc or Hash
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Proc.instance_methods.collect{|m| m.to_s}
-          candidates |= Hash.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        when /^(:[^:.]*)$/
-          # Symbol
-          if Symbol.respond_to?(:all_symbols)
-            sym = $1
-            candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
-            candidates.grep(/^#{sym}/)
-          else
-            []
-          end
-
-        when /^::([A-Z][^:\.\(]*)$/
-          # Absolute Constant or class methods
-          receiver = $1
-          candidates = Object.constants.collect{|m| m.to_s}
-          candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
-
-        when /^([A-Z].*)::([^:.]*)$/
-          # Constant or class methods
-          receiver = $1
-          message = Regexp.quote($2)
-          begin
-            candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
-            candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
-          rescue Exception
-            candidates = []
-          end
-          candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
-
-        when /^(:[^:.]+)\.([^.]*)$/
-          # Symbol
-          receiver = $1
-          message = Regexp.quote($2)
-
-          candidates = Symbol.instance_methods.collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
-          # Numeric
-          receiver = $1
-          message = Regexp.quote($5)
-
-          begin
-            candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
-          rescue Exception
-            candidates = []
-          end
-          select_message(receiver, message, candidates)
-
-        when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
-          # Numeric(0xFFFF)
-          receiver = $1
-          message = Regexp.quote($2)
-
-          begin
-            candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
-          rescue Exception
-            candidates = []
-          end
-          select_message(receiver, message, candidates)
-
-        when /^(\$[^.]*)$/
-          regmessage = Regexp.new(Regexp.quote($1))
-          candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
-
-        when /^([^."].*)\.([^.]*)$/
-          # variable
-          receiver = $1
-          message = Regexp.quote($2)
-
-          gv = eval("global_variables", bind).collect{|m| m.to_s}
-          lv = eval("local_variables", bind).collect{|m| m.to_s}
-          cv = eval("self.class.constants", bind).collect{|m| m.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{|m| m.to_s}
-            rescue Exception
-              candidates = []
-            end
-          else
-            # func1.func2
-            candidates = []
-            ObjectSpace.each_object(Module){|m|
-              begin
-                name = m.name
-              rescue Exception
-                name = ""
-              end
-              next if name != "IRB::Context" and
-              /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
-              candidates.concat m.instance_methods(false).collect{|x| x.to_s}
-            }
-            candidates.sort!
-            candidates.uniq!
-          end
-          select_message(receiver, message, candidates)
-
-        when /^\.([^.]*)$/
-          # unknown(maybe String)
-
-          receiver = ""
-          message = Regexp.quote($1)
-
-          candidates = String.instance_methods(true).collect{|m| m.to_s}
-          select_message(receiver, message, candidates)
-
-        else
-          candidates = eval("methods | private_methods | local_variables | self.class.constants", bind).collect{|m| m.to_s}
-
-          (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
-        end
-      end
-    end
-
-    def self.select_message(receiver, message, candidates)
-      candidates.grep(/^#{message}/).collect do |e|
-	case e
-	when /^[a-zA-Z_]/
-	  receiver + "." + e
-	when /^[0-9]/
-	when *Operators
-	  #receiver + " " + e
-	end
-      end
-    end
-  end
-end
-
+# taken from irb
+
+require "readline"
+
+class Pry
+
+  # Implements tab completion for Readline in Pry
+  module InputCompleter
+    
+    if Readline.respond_to?("basic_word_break_characters=")
+      Readline.basic_word_break_characters= " \t\n\"\\'`><=;|&{("
+    end
+
+    Readline.completion_append_character = nil
+
+    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 = ["%", "&", "*", "**", "+",  "-",  "/",
+                 "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
+                 "[]", "[]=", "^", "!", "!=", "!~"]
+
+    # Return a new completion proc for use by Readline.
+    # @param [Binding] target The current binding context.
+    # @param [Array<String>] commands The array of Pry commands.
+    def self.build_completion_proc(target, commands=[""])
+      proc do |input|
+        bind = target
+
+        case input
+        when /^(\/[^\/]*\/)\.([^.]*)$/
+          # Regexp
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Regexp.instance_methods.collect{|m| m.to_s}
+          select_message(receiver, message, candidates)
+
+        when /^([^\]]*\])\.([^.]*)$/
+          # Array
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Array.instance_methods.collect{|m| m.to_s}
+          select_message(receiver, message, candidates)
+
+        when /^([^\}]*\})\.([^.]*)$/
+          # Proc or Hash
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Proc.instance_methods.collect{|m| m.to_s}
+          candidates |= Hash.instance_methods.collect{|m| m.to_s}
+          select_message(receiver, message, candidates)
+
+        when /^(:[^:.]*)$/
+          # Symbol
+          if Symbol.respond_to?(:all_symbols)
+            sym = $1
+            candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
+            candidates.grep(/^#{sym}/)
+          else
+            []
+          end
+
+        when /^::([A-Z][^:\.\(]*)$/
+          # Absolute Constant or class methods
+          receiver = $1
+          candidates = Object.constants.collect{|m| m.to_s}
+          candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
+
+        when /^([A-Z].*)::([^:.]*)$/
+          # Constant or class methods
+          receiver = $1
+          message = Regexp.quote($2)
+          begin
+            candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
+            candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
+          rescue Exception
+            candidates = []
+          end
+          candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
+
+        when /^(:[^:.]+)\.([^.]*)$/
+          # Symbol
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Symbol.instance_methods.collect{|m| m.to_s}
+          select_message(receiver, message, candidates)
+
+        when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
+          # Numeric
+          receiver = $1
+          message = Regexp.quote($5)
+
+          begin
+            candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+          rescue Exception
+            candidates = []
+          end
+          select_message(receiver, message, candidates)
+
+        when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
+          # Numeric(0xFFFF)
+          receiver = $1
+          message = Regexp.quote($2)
+
+          begin
+            candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+          rescue Exception
+            candidates = []
+          end
+          select_message(receiver, message, candidates)
+
+        when /^(\$[^.]*)$/
+          regmessage = Regexp.new(Regexp.quote($1))
+          candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
+
+        when /^([^."].*)\.([^.]*)$/
+          # variable
+          receiver = $1
+          message = Regexp.quote($2)
+
+          gv = eval("global_variables", bind).collect{|m| m.to_s}
+          lv = eval("local_variables", bind).collect{|m| m.to_s}
+          cv = eval("self.class.constants", bind).collect{|m| m.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{|m| m.to_s}
+            rescue Exception
+              candidates = []
+            end
+          else
+            # func1.func2
+            candidates = []
+            ObjectSpace.each_object(Module){|m|
+              begin
+                name = m.name
+              rescue Exception
+                name = ""
+              end
+              next if name != "IRB::Context" and
+              /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+              candidates.concat m.instance_methods(false).collect{|x| x.to_s}
+            }
+            candidates.sort!
+            candidates.uniq!
+          end
+          select_message(receiver, message, candidates)
+
+        when /^\.([^.]*)$/
+          # unknown(maybe String)
+
+          receiver = ""
+          message = Regexp.quote($1)
+
+          candidates = String.instance_methods(true).collect{|m| m.to_s}
+          select_message(receiver, message, candidates)
+
+        else
+          candidates = eval("methods | private_methods | local_variables | self.class.constants", bind).collect{|m| m.to_s}
+
+          (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
+        end
+      end
+    end
+
+    def self.select_message(receiver, message, candidates)
+      candidates.grep(/^#{message}/).collect do |e|
+	case e
+	when /^[a-zA-Z_]/
+	  receiver + "." + e
+	when /^[0-9]/
+	when *Operators
+	  #receiver + " " + e
+	end
+      end
+    end
+  end
+end
+