pry 0.9.10pre1-i386-mswin32 → 0.9.11-i386-mswin32

data/lib/pry/completion.rb

@@ -1,9 +1,31 @@
 # taken from irb
 
-require "readline"
-
 class Pry
 
+  module BondCompleter
+
+    def self.build_completion_proc(target, pry=nil, commands=[""])
+      if !@started
+        @started = true
+        start
+      end
+
+      Pry.current[:pry] = pry
+      proc{ |*a| Bond.agent.call(*a) }
+    end
+
+    def self.start
+      Bond.start(:eval_binding => lambda{ Pry.current[:pry].current_context })
+      Bond.complete(:on => /\A/) do |input|
+        Pry.commands.complete(input.line,
+                             :pry_instance => Pry.current[:pry],
+                             :target       => Pry.current[:pry].current_context,
+                             :command_set  => Pry.current[:pry].commands)
+      end
+    end
+
+  end
+
   # Implements tab completion for Readline in Pry
   module InputCompleter
 
@@ -41,36 +63,51 @@ class Pry
     # 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=[""])
+    def self.build_completion_proc(target, pry=nil, commands=[""])
+
       proc do |input|
+
+        # 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(input)
+
+        unless path.call.empty?
+          target, _ = Pry::Helpers::BaseHelpers.context_from_object_path(path.call, pry)
+          target = target.last
+        end
+
         begin
           bind = target
 
           case input
+
+
+          # Complete stdlib symbols
+
           when /^(\/[^\/]*\/)\.([^.]*)$/
             # Regexp
             receiver = $1
             message = Regexp.quote($2)
 
-            candidates = Regexp.instance_methods.collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
+            candidates = Regexp.instance_methods.collect(&:to_s)
+            select_message(path, 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)
+            candidates = Array.instance_methods.collect(&:to_s)
+            select_message(path, 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)
+            candidates = Proc.instance_methods.collect(&:to_s)
+            candidates |= Hash.instance_methods.collect(&:to_s)
+            select_message(path, receiver, message, candidates)
 
           when /^(:[^:.]*)$/
             # Symbol
@@ -86,16 +123,32 @@ class Pry
           when /^::([A-Z][^:\.\(]*)$/
             # Absolute Constant or class methods
             receiver = $1
-            candidates = Object.constants.collect{|m| m.to_s}
+            candidates = Object.constants.collect(&:to_s)
             candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
 
+
+          # Complete target symbols
+
+          when /^([A-Z][A-Za-z0-9]*)$/
+            # 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 /^([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)
+              candidates = eval("#{receiver}.constants.collect(&:to_s)", bind)
+              candidates |= eval("#{receiver}.methods.collect(&:to_s)", bind)
             rescue RescuableException
               candidates = []
             end
@@ -106,8 +159,8 @@ class Pry
             receiver = $1
             message = Regexp.quote($2)
 
-            candidates = Symbol.instance_methods.collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
+            candidates = Symbol.instance_methods.collect(&:to_s)
+            select_message(path, receiver, message, candidates)
 
           when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
             # Numeric
@@ -115,42 +168,43 @@ class Pry
             message = Regexp.quote($5)
 
             begin
-              candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
+              candidates = eval(receiver, bind).methods.collect(&:to_s)
             rescue RescuableException
               candidates = []
             end
-            select_message(receiver, message, candidates)
+            select_message(path, receiver, message, candidates)
 
-          when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
+          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}
+              candidates = eval(receiver, bind).methods.collect(&:to_s)
             rescue RescuableException
               candidates = []
             end
-            select_message(receiver, message, candidates)
+            select_message(path, receiver, message, candidates)
 
           when /^(\$[^.]*)$/
+            # Global variables
             regmessage = Regexp.new(Regexp.quote($1))
-            candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
+            candidates = global_variables.collect(&:to_s).grep(regmessage)
 
           when /^([^."].*)\.([^.]*)$/
-            # variable
+            # 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}
+            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{|m| m.to_s}
+                candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
               rescue RescuableException
                 candidates = []
               end
@@ -169,35 +223,35 @@ class Pry
                 # jruby doesn't always provide #instance_methods() on each
                 # object.
                 if m.respond_to?(:instance_methods)
-                  candidates.concat m.instance_methods(false).collect{|x| x.to_s}
+                  candidates.concat m.instance_methods(false).collect(&:to_s)
                 end
               }
               candidates.sort!
               candidates.uniq!
             end
-            select_message(receiver, message, candidates)
+            select_message(path, receiver, message, candidates)
 
           when /^\.([^.]*)$/
-            # unknown(maybe String)
-
+            # Unknown(maybe String)
             receiver = ""
             message = Regexp.quote($1)
 
-            candidates = String.instance_methods(true).collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
+            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{|m| m.to_s}
+            ).collect(&:to_s)
 
             if eval("respond_to?(:class_variables)", bind)
-              candidates += eval("class_variables", bind).collect { |m| m.to_s }
+              candidates += eval("class_variables", bind).collect(&:to_s)
             end
-
-            (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
+            candidates = (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
+            candidates.collect(&path)
           end
         rescue RescuableException
           []
@@ -205,17 +259,37 @@ class Pry
       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
+    def self.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 self.build_path(input)
+
+      # check to see if the input is a regex
+      return proc {|input| input.to_s }, input if input[/\/\./]
+
+      trailing_slash = input.end_with?('/')
+      contexts = input.chomp('/').split(/\//)
+      input = contexts[-1]
+
+      path = proc do |input|
+        p = contexts[0..-2].push(input).join('/')
+        p += '/' if trailing_slash && !input.nil?
+        p
       end
+
+      return path, input
     end
   end
 end
-

data/lib/pry/config.rb

@@ -112,6 +112,14 @@ class Pry
     #   Pry.config.prompt = proc { |obj, nest_level, _pry_| "#{obj}:#{nest_level}> " }
     attr_accessor :prompt
 
+    # The display name that is part of the prompt.  Default is 'pry'. 
+    # You can set your own name so you can identify which project your current pry session
+    # is using.  This is useful if you have a local pryrc file in a Rails project for example.
+    # @return [String]
+    # @example 
+    #   Pry.config.prompt_name = 'my_rails_project'
+    attr_accessor :prompt_name
+    
     # The default editor to use. Defaults to $VISUAL, $EDITOR, or a sensible fallback
     # for the platform.
     # If `editor` is a String then that string is used as the shell
@@ -228,6 +236,9 @@ class Pry
     #   Pry.config.extra_sticky_locals = { :random_number => proc {
     #   rand(10) } }
     attr_accessor :extra_sticky_locals
+
+    # @return [#build_completion_proc] A completer to use.
+    attr_accessor :completer
   end
 end
 

data/lib/pry/core_extensions.rb

@@ -1,3 +1,24 @@
+class Pry
+  # @return [Array] Code of the method used when implementing Pry's
+  #   __binding__, along with line indication to be used with instance_eval (and
+  #   friends).
+  #
+  # @see Object#__binding__
+  BINDING_METHOD_IMPL = [<<-METHOD, __FILE__, __LINE__ + 1]
+    # Get a binding with 'self' set to self, and no locals.
+    #
+    # The default definee is determined by the context in which the
+    # definition is eval'd.
+    #
+    # Please don't call this method directly, see {__binding__}.
+    #
+    # @return [Binding]
+    def __pry__
+      binding
+    end
+  METHOD
+end
+
 class Object
   # Start a Pry REPL on self.
   #
@@ -45,46 +66,36 @@ class Object
   #
   # @return [Binding]
   def __binding__
+    # If you ever feel like changing this method, be careful about variables
+    # that you use. They shouldn't be inserted into the binding that will
+    # eventually be returning.
+
     # When you're cd'd into a class, methods you define should be added to it.
     if is_a?(Module)
       # class_eval sets both self and the default definee to this class.
       return class_eval "binding"
     end
 
-    unless respond_to?(:__binding_impl__)
-      binding_impl_method = [<<-METHOD, __FILE__, __LINE__ + 1]
-        # Get a binding with 'self' set to self, and no locals.
-        #
-        # The default definee is determined by the context in which the
-        # definition is eval'd.
-        #
-        # Please don't call this method directly, see {__binding__}.
-        #
-        # @return [Binding]
-        def __binding_impl__
-          binding
-        end
-      METHOD
-
+    unless respond_to?(:__pry__)
       # The easiest way to check whether an object has a working singleton class
       # is to try and define a method on it. (just checking for the presence of
       # the singleton class gives false positives for `true` and `false`).
-      # __binding_impl__ is just the closest method we have to hand, and using
+      # __pry__ is just the closest method we have to hand, and using
       # it has the nice property that we can memoize this check.
       begin
         # instance_eval sets the default definee to the object's singleton class
-        instance_eval(*binding_impl_method)
+        instance_eval *Pry::BINDING_METHOD_IMPL
 
       # If we can't define methods on the Object's singleton_class. Then we fall
       # back to setting the default definee to be the Object's class. That seems
       # nicer than having a REPL in which you can't define methods.
       rescue TypeError
         # class_eval sets the default definee to self.class
-        self.class.class_eval(*binding_impl_method)
+        self.class.class_eval *Pry::BINDING_METHOD_IMPL
       end
     end
 
-    __binding_impl__
+    __pry__
   end
 end
 

data/lib/pry/editor.rb

@@ -0,0 +1,129 @@
+class Pry
+  class Editor
+    extend Pry::Helpers::BaseHelpers
+    extend Pry::Helpers::CommandHelpers
+
+    class << self
+      def edit_tempfile_with_content(initial_content, line=1)
+        temp_file do |f|
+          f.puts(initial_content)
+          f.flush
+          f.close(false)
+          invoke_editor(f.path, line, true)
+          File.read(f.path)
+        end
+      end
+
+      def invoke_editor(file, line, blocking=true)
+        raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless Pry.config.editor
+
+        editor_invocation = build_editor_invocation_string(file, line, blocking)
+        return nil unless editor_invocation
+
+        if jruby?
+          open_editor_on_jruby(editor_invocation)
+        else
+          open_editor(editor_invocation)
+        end
+      end
+
+      private
+
+      # Generate the string that's used to start the editor. This includes
+      # all the flags we want as well as the file and line number we
+      # want to open at.
+      def build_editor_invocation_string(file, line, blocking)
+
+        if Pry.config.editor.respond_to?(:call)
+          args = [file, line, blocking][0...(Pry.config.editor.arity)]
+          Pry.config.editor.call(*args)
+        else
+          sanitized_file = if windows?
+                             file.gsub(/\//, '\\')
+                           else
+                             Shellwords.escape(file)
+                           end
+
+          "#{Pry.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
+        end
+      end
+
+      # Start the editor running, using the calculated invocation string
+      def open_editor(editor_invocation)
+        # Note we dont want to use Pry.config.system here as that
+        # may be invoked non-interactively (i.e via Open4), whereas we want to
+        # ensure the editor is always interactive
+        system(editor_invocation) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
+      end
+
+      # We need JRuby specific code here cos just shelling out using
+      # system() appears to be pretty broken :/
+      def open_editor_on_jruby(editor_invocation)
+        begin
+          require 'spoon'
+          pid = Spoon.spawnp(*editor_invocation.split)
+          Process.waitpid(pid)
+        rescue FFI::NotFoundError
+          system(editor_invocation)
+        end
+      end
+
+      # Some editors that run outside the terminal allow you to control whether or
+      # not to block the process from which they were launched (in this case, Pry).
+      # For those editors, return the flag that produces the desired behavior.
+      def blocking_flag_for_editor(blocking)
+        case editor_name
+        when /^emacsclient/
+          '--no-wait' unless blocking
+        when /^[gm]vim/
+          '--nofork' if blocking
+        when /^jedit/
+          '-wait' if blocking
+        when /^mate/, /^subl/
+          '-w' if blocking
+        end
+      end
+
+      # Return the syntax for a given editor for starting the editor
+      # and moving to a particular line within that file
+      def start_line_syntax_for_editor(file_name, line_number)
+        # special case for 1st line
+        return file_name if line_number <= 1
+
+        case editor_name
+        when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
+          "+#{line_number} #{file_name}"
+        when /^mate/, /^geany/
+          "-l #{line_number} #{file_name}"
+        when /^subl/
+          "#{file_name}:#{line_number}"
+        when /^uedit32/
+          "#{file_name}/#{line_number}"
+        when /^jedit/
+          "#{file_name} +line:#{line_number}"
+        else
+          if windows?
+            "#{file_name}"
+          else
+            "+#{line_number} #{file_name}"
+          end
+        end
+      end
+
+      # Get the name of the binary that Pry.config.editor points to.
+      #
+      # This is useful for deciding which flags we pass to the editor as
+      # we can just use the program's name and ignore any absolute paths.
+      #
+      # @example
+      #   Pry.config.editor="/home/conrad/bin/textmate -w"
+      #   editor_name
+      #   # => textmate
+      #
+      def editor_name
+        File.basename(Pry.config.editor).split(" ").first
+      end
+
+    end
+  end
+end