pry 0.6.7-i386-mingw32

data/lib/pry/completion.rb

@@ -0,0 +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
+

data/lib/pry/core_extensions.rb

@@ -0,0 +1,55 @@
+class Pry
+  module ObjectExtensions
+
+    # Start a Pry REPL.
+    # This method differs from `Pry.start` in that it does not
+    # support an options hash. Also, when no parameter is provided, the Pry
+    # session will start on the implied receiver rather than on
+    # top-level (as in the case of `Pry.start`).
+    # It has two forms of invocation. In the first form no parameter
+    # should be provided and it will start a pry session on the
+    # receiver. In the second form it should be invoked without an
+    # explicit receiver and one parameter; this will start a Pry
+    # session on the parameter.
+    # @param [Object, Binding] target The receiver of the Pry session.
+    # @example First form
+    #   "dummy".pry
+    # @example Second form
+    #    pry "dummy"
+    # @example Start a Pry session on current self (whatever that is)
+    #   pry
+    def pry(target=self)
+      Pry.start(target)
+    end
+
+    # Return a binding object for the receiver.
+    def __binding__
+      if is_a?(Module)
+        return class_eval "binding"
+      end
+
+      unless respond_to? :__binding_impl__
+        begin
+          instance_eval %{
+            def __binding_impl__
+              binding
+            end
+          }
+        rescue TypeError
+          self.class.class_eval %{
+            def __binding_impl__
+              binding
+            end
+          }
+        end
+      end
+
+      __binding_impl__
+    end
+  end
+end
+
+# bring the extensions into Object
+class Object
+  include Pry::ObjectExtensions
+end

data/lib/pry/hooks.rb

@@ -0,0 +1,8 @@
+class Pry
+
+  # The default hooks - display messages when beginning and ending Pry sessions.
+  DEFAULT_HOOKS = {
+    :before_session => proc { |out, obj| out.puts "Beginning Pry session for #{Pry.view_clip(obj)}" },
+    :after_session => proc { |out, obj| out.puts "Ending Pry session for #{Pry.view_clip(obj)}" }
+  }
+end

data/lib/pry/print.rb

@@ -0,0 +1,19 @@
+class Pry
+
+  # The default print object - only show first line of backtrace and
+  # prepend output with `=>`
+  DEFAULT_PRINT = proc do |output, value|
+    case value
+    when Exception
+      output.puts "#{value.class}: #{value.message}"
+      output.puts "from #{value.backtrace.first}"
+    else
+      if Pry.color
+        output.puts "=> #{CodeRay.scan(Pry.view(value), :ruby).term}"
+      else
+        output.puts "=> #{Pry.view(value)}"
+      end
+    end
+  end
+end
+  

data/lib/pry/prompts.rb

@@ -0,0 +1,26 @@
+class Pry
+
+  
+  # The default prompt; includes the target and nesting level
+  DEFAULT_PROMPT = [
+                    proc do |target_self, nest_level|
+
+                      if nest_level == 0
+                        "pry(#{Pry.view_clip(target_self)})> "
+                      else
+                        "pry(#{Pry.view_clip(target_self)}):#{Pry.view_clip(nest_level)}> "
+                      end
+                    end,
+                    
+                    proc do |target_self, nest_level|
+                      if nest_level == 0
+                        "pry(#{Pry.view_clip(target_self)})* "
+                      else
+                        "pry(#{Pry.view_clip(target_self)}):#{Pry.view_clip(nest_level)}* "
+                      end
+                    end
+                   ]
+
+  # A simple prompt - doesn't display target or nesting level
+  SIMPLE_PROMPT = [proc { ">> " }, proc { ">* " }]
+end

data/lib/pry/pry_class.rb

@@ -0,0 +1,186 @@
+# @author John Mair (banisterfiend)
+class Pry
+
+  # class accessors
+  class << self
+
+    # Get nesting data.
+    # This method should not need to be accessed directly.
+    # @return [Array] The unparsed nesting information.
+    attr_reader :nesting
+
+    # Get last value evaluated by Pry.
+    # This method should not need to be accessed directly.
+    # @return [Object] The last result.
+    attr_accessor :last_result
+
+    # Get the active Pry instance that manages the active Pry session.
+    # This method should not need to be accessed directly.
+    # @return [Pry] The active Pry instance.
+    attr_accessor :active_instance
+
+    # Get/Set the object to use for input by default by all Pry instances.
+    # @return [#readline] The object to use for input by default by all
+    #   Pry instances.
+    attr_accessor :input
+
+    # Get/Set the object to use for output by default by all Pry instances.
+    # @return [#puts] The object to use for output by default by all
+    #   Pry instances.
+    attr_accessor :output
+
+    # Get/Set the object to use for commands by default by all Pry instances.
+    # @return [Pry::CommandBase] The object to use for commands by default by all
+    #   Pry instances.
+    attr_accessor :commands
+
+    # Get/Set the Proc to use for printing by default by all Pry
+    # instances.
+    # This is the 'print' component of the REPL.
+    # @return [Proc] The Proc to use for printing by default by all
+    #   Pry instances.
+    attr_accessor :print
+
+    # Get/Set the Hash that defines Pry hooks used by default by all Pry
+    # instances.
+    # @return [Hash] The hooks used by default by all Pry instances.
+    # @example
+    #   Pry.hooks :before_session => proc { puts "hello" },
+    #     :after_session => proc { puts "goodbye" }
+    attr_accessor :hooks
+
+    # Get the array of Procs to be used for the prompts by default by
+    # all Pry instances.
+    # @return [Array<Proc>] The array of Procs to be used for the
+    #   prompts by default by all Pry instances.
+    attr_accessor :prompt
+
+    # Value returned by last executed Pry command.
+    # @return [Object] The command value
+    attr_accessor :cmd_ret_value
+
+    # Determines whether colored output is enabled.
+    # @return [Boolean] 
+    attr_accessor :color
+  end
+  
+  # Start a Pry REPL.
+  # @param [Object, Binding] target The receiver of the Pry session
+  # @param [Hash] options
+  # @option options (see Pry#initialize)
+  # @example
+  #   Pry.start(Object.new, :input => MyInput.new)
+  def self.start(target=TOPLEVEL_BINDING, options={})
+    new(options).repl(target)
+  end
+
+  # A custom version of `Kernel#inspect`.
+  # This method should not need to be accessed directly.
+  # @param obj The object to view.
+  # @return [String] The string representation of `obj`.
+  def self.view(obj)
+    case obj
+    when String, Hash, Array, Symbol, nil
+      obj.inspect
+    else
+      obj.to_s
+    end
+  end
+
+  # A version of `Pry.view` that clips the output to `max_size` chars.
+  # In case of > `max_size` chars the `#<Object...> notation is used.
+  # @param obj The object to view.
+  # @param max_size The maximum number of chars before clipping occurs.
+  # @return [String] The string representation of `obj`.
+  def self.view_clip(obj, max_size=60)
+    if Pry.view(obj).size < max_size
+      Pry.view(obj)
+    else
+      "#<#{obj.class}:%#x>" % (obj.object_id << 1)
+    end
+  end
+
+  # Run a Pry command from outside a session. The commands available are
+  # those referenced by `Pry.commands` (the default command set).
+  # Command output is suppresed by default, this is because the return
+  # value (if there is one) is likely to be more useful.
+  # @param [String] arg_string The Pry command (including arguments,
+  #   if any).
+  # @param [Hash] options Optional named parameters.
+  # @return [Object] The return value of the Pry command.
+  # @option options [Object, Binding] :context The object context to run the
+  #   command under. Defaults to `TOPLEVEL_BINDING` (main).
+  # @option options [Boolean] :show_output Whether to show command
+  #   output. Defaults to false.
+  # @example Run at top-level with no output.
+  #   Pry.run_command "ls"
+  # @example Run under Pry class, returning only public methods.
+  #   Pry.run_command "ls -m", :context => Pry
+  # @example Display command output.
+  #   Pry.run_command "ls -av", :show_output => true
+  def self.run_command(arg_string, options={})
+    name, arg_string = arg_string.split(/\s+/, 2)
+    arg_string = "" if !arg_string
+    
+    options = {
+      :context => TOPLEVEL_BINDING,
+      :show_output => false
+    }.merge!(options)
+    
+    null_output = Object.new.tap { |v| v.instance_eval { def puts(*) end } }
+    
+    commands = Pry.commands.dup
+    commands.output = options[:show_output] ? Pry.output : null_output
+    commands.target = Pry.binding_for(options[:context])
+
+    cmd = commands.commands[name]
+    if cmd
+      action = cmd[:action]
+      commands.instance_exec(*Shellwords.shellwords(arg_string), &action)
+    else
+      raise "No such Pry command: #{name}"
+    end
+  end
+
+  # Set all the configurable options back to their default values
+  def self.reset_defaults
+    @input = Readline
+    @output = $stdout
+    @commands = Pry::Commands
+    @prompt = DEFAULT_PROMPT
+    @print = DEFAULT_PRINT
+    @hooks = DEFAULT_HOOKS
+    @color = false
+  end
+
+  self.reset_defaults
+
+  @nesting = []
+  def @nesting.level
+    last.is_a?(Array) ? last.first : nil
+  end
+
+  # Return all active Pry sessions.
+  # @return [Array<Pry>] Active Pry sessions.
+  def self.sessions
+    # last element in nesting array is the pry instance
+    nesting.map(&:last)
+  end
+
+  # Return a `Binding` object for `target` or return `target` if it is
+  # already a `Binding`.
+  # In the case where `target` is top-level then return `TOPLEVEL_BINDING`
+  # @param [Object] target The object to get a `Binding` object for.
+  # @return [Binding] The `Binding` object.
+  def self.binding_for(target)
+    if target.is_a?(Binding)
+      target
+    else
+      if target == TOPLEVEL_BINDING.eval('self')
+        TOPLEVEL_BINDING
+      else
+        target.__binding__
+      end
+    end
+  end
+end