pry 0.3.0 → 0.4.0pre1

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,47 @@
+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__
+        self.class.class_eval <<-EXTRA
+        def __binding_impl__
+          binding
+        end
+        EXTRA
+      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(obj)}" },
+    :after_session => proc { |out, obj| out.puts "Ending Pry session for #{Pry.view(obj)}" }
+  }
+end

data/lib/pry/print.rb

@@ -0,0 +1,15 @@
+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
+      output.puts "=> #{Pry.view(value)}"
+    end
+  end
+end
+  

data/lib/pry/prompts.rb

@@ -0,0 +1,24 @@
+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(target_self)})> "
+                      else
+                        "pry(#{Pry.view(target_self)}):#{Pry.view(nest_level)}> "
+                      end
+                    end,
+                    
+                    proc do |target_self, nest_level|
+                      if nest_level == 0
+                        "pry(#{Pry.view(target_self)})* "
+                      else
+                        "pry(#{Pry.view(target_self)}):#{Pry.view(nest_level)}* "
+                      end
+                    end
+                   ]
+
+  # A simple prompt - doesn't display target or nesting level
+  SIMPLE_PROMPT = [proc { "pry> " }, proc { "pry* " }]
+end

data/lib/pry/pry_class.rb

@@ -0,0 +1,109 @@
+require 'readline'
+
+# @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
+  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
+
+  # Set all the configurable options back to their default values
+  def self.reset_defaults
+    @input = Readline
+    @output = $stdout
+
+    # FIXME
+    @commands = Pry::Commands
+    @prompt = DEFAULT_PROMPT
+    @print = DEFAULT_PRINT
+    @hooks = DEFAULT_HOOKS
+  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
+end

data/lib/pry/pry_instance.rb

@@ -0,0 +1,309 @@
+require 'readline'
+
+class Pry
+
+  # The list of configuration options.
+  ConfigOptions = [:input, :output, :commands, :print,
+                   :prompt, :hooks]
+
+  attr_accessor *ConfigOptions
+
+  # Create a new `Pry` object.
+  # @param [Hash] options The optional configuration parameters.
+  # @option options [#readline] :input The object to use for input. 
+  # @option options [#puts] :output The object to use for output. 
+  # @option options [Pry::CommandBase] :commands The object to use for
+  #   commands. (see commands.rb)
+  # @option options [Hash] :hooks The defined hook Procs (see hooks.rb)
+  # @option options [Array<Proc>] :default_prompt The array of Procs
+  #   to use for the prompts. (see prompts.rb)
+  # @option options [Proc] :print The Proc to use for the 'print'
+  #   component of the REPL. (see print.rb)
+  def initialize(options={})
+
+    h = {}
+    ConfigOptions.each { |v| h[v] = Pry.send(v) }
+    default_options = h
+    default_options.merge!(options)
+
+    ConfigOptions.each do |key|
+      instance_variable_set("@#{key}", default_options[key])
+    end
+  end
+
+  # Get nesting data.
+  # This method should not need to be accessed directly.
+  # @return [Array] The unparsed nesting information.
+  def nesting
+    self.class.nesting
+  end
+
+  # Set nesting data.
+  # This method should not need to be accessed directly.
+  # @param v nesting data.
+  def nesting=(v)
+    self.class.nesting = v
+  end
+
+  # Return parent of current Pry session.
+  # @return [Pry] The parent of the current Pry session.
+  def parent
+    idx = Pry.sessions.index(self)
+
+    if idx > 0
+      Pry.sessions[idx - 1]
+    else
+      nil
+    end
+  end
+
+  # Execute the hook `hook_name`, if it is defined.
+  # @param [Symbol] hook_name The hook to execute
+  # @param [Array] args The arguments to pass to the hook.
+  def exec_hook(hook_name, *args, &block)
+    hooks[hook_name].call(*args, &block) if hooks[hook_name]
+  end
+
+  # Start a read-eval-print-loop.
+  # If no parameter is given, default to top-level (main).
+  # @param [Object, Binding] target The receiver of the Pry session
+  # @return [Object] The target of the Pry session
+  # @example
+  #   Pry.new.repl(Object.new)
+  def repl(target=TOPLEVEL_BINDING)
+    target = binding_for(target)
+    target_self = target.eval('self')
+
+    exec_hook :before_session, output, target_self
+
+    # cannot rely on nesting.level as
+    # nesting.level changes with new sessions
+    nesting_level = nesting.size
+
+    Pry.active_instance = self
+
+    # Make sure special locals exist
+    target.eval("_pry_ = Pry.active_instance")
+    target.eval("_ = Pry.last_result")
+
+    break_level = catch(:breakout) do
+      nesting.push [nesting.size, target_self, self]
+      loop do
+        rep(target)
+      end
+    end
+
+    nesting.pop
+
+    exec_hook :after_session, output, target_self
+
+    # keep throwing until we reach the desired nesting level
+    if nesting_level != break_level
+      throw :breakout, break_level
+    end
+
+    target_self
+  end
+
+  # Perform a read-eval-print.
+  # If no parameter is given, default to top-level (main).
+  # @param [Object, Binding] target The receiver of the read-eval-print
+  # @example
+  #   Pry.new.rep(Object.new)
+  def rep(target=TOPLEVEL_BINDING)
+    target = binding_for(target)
+    print.call output, re(target)
+  end
+
+  # Perform a read-eval
+  # If no parameter is given, default to top-level (main).
+  # @param [Object, Binding] target The receiver of the read-eval-print
+  # @return [Object] The result of the eval or an `Exception` object in case of error.
+  # @example
+  #   Pry.new.re(Object.new)
+  def re(target=TOPLEVEL_BINDING)
+    target = binding_for(target)
+
+    if input == Readline
+      # Readline tab completion
+      Readline.completion_proc = Pry::InputCompleter.build_completion_proc(target, commands.commands.keys)
+    end
+
+    # eval the expression and save to last_result
+    Pry.last_result = target.eval r(target)
+
+    # save the pry instance to active_instance
+    Pry.active_instance = self
+
+    # define locals _pry_ and _ (active instance and last expression)
+    target.eval("_pry_ = Pry.active_instance")
+    target.eval("_ = Pry.last_result")
+  rescue SystemExit => e
+    exit
+  rescue Exception => e
+    e
+  end
+
+  # Perform a read.
+  # If no parameter is given, default to top-level (main).
+  # This is a multi-line read; so the read continues until a valid
+  # Ruby expression is received.
+  # Pry commands are also accepted here and operate on the target.
+  # @param [Object, Binding] target The receiver of the read.
+  # @return [String] The Ruby expression.
+  # @example
+  #   Pry.new.r(Object.new)
+  def r(target=TOPLEVEL_BINDING)
+    target = binding_for(target)
+    eval_string = ""
+
+    loop do
+      current_prompt = select_prompt(eval_string.empty?, target.eval('self'))
+
+      val = readline(current_prompt)
+      val.chomp!
+
+      process_commands(val, eval_string, target)
+      eval_string << "#{val}\n"
+
+      break eval_string if valid_expression?(eval_string)
+    end
+  end
+
+  # Process Pry commands. Pry commands are not Ruby methods and are evaluated
+  # prior to Ruby expressions.
+  # Commands can be modified/configured by the user: see `Pry::Commands`
+  # This method should not need to be invoked directly - it is called
+  # by `Pry#r`.
+  # @param [String] val The current line of input.
+  # @param [String] eval_string The cumulative lines of input for
+  #   multi-line input.
+  # @param [Binding] target The receiver of the commands.
+  def process_commands(val, eval_string, target)
+    def val.clear() replace("") end
+    def eval_string.clear() replace("") end
+
+    pattern, data = commands.commands.find do |name, data|
+      /^#{name}(?!\S)(?:\s+(.+))?/ =~ val
+    end
+
+    if pattern
+      args_string = $1
+      args = args_string ? args_string.split : []
+      action = data[:action]
+      
+      options = {
+        :val => val,
+        :eval_string => eval_string,
+        :nesting => nesting,
+        :commands => commands.commands
+      }
+
+      # set some useful methods to be used by the action blocks
+      commands.opts = options
+      commands.target = target
+      commands.output = output
+
+      case action.arity <=> 0
+      when -1
+
+        # Use instance_exec() to make the `opts` method, etc available
+        commands.instance_exec(*args, &action)
+      when 1, 0
+
+        # ensure that we get the right number of parameters
+        # since 1.8.7 complains about incorrect arity (1.9.2
+        # doesn't care)
+        args_with_corrected_arity = args.values_at *0..(action.arity - 1)
+        commands.instance_exec(*args_with_corrected_arity, &action)
+      end
+      
+      val.clear
+    end
+  end
+
+  # Returns the next line of input to be used by the pry instance.
+  # This method should not need to be invoked directly.
+  # @param [String] current_prompt The prompt to use for input.
+  # @return [String] The next line of input.
+  def readline(current_prompt="> ")
+
+    if input == Readline
+
+      # Readline must be treated differently
+      # as it has a second parameter.
+      input.readline(current_prompt, true)
+    else
+      if input.method(:readline).arity == 1
+        input.readline(current_prompt)
+      else
+        input.readline
+      end
+    end
+  end
+
+  # Returns the appropriate prompt to use.
+  # This method should not need to be invoked directly.
+  # @param [Boolean] first_line Whether this is the first line of input
+  #   (and not multi-line input).
+  # @param [Object] target_self The receiver of the Pry session.
+  # @return [String] The prompt.
+  def select_prompt(first_line, target_self)
+
+    if first_line
+      Array(prompt).first.call(target_self, nesting.level)
+    else
+      Array(prompt).last.call(target_self, nesting.level)
+    end
+  end
+
+  if RUBY_VERSION =~ /1.9/
+    require 'ripper'
+
+    # Determine if a string of code is a valid Ruby expression.
+    # Ruby 1.9 uses Ripper, Ruby 1.8 uses RubyParser.
+    # @param [String] code The code to validate.
+    # @return [Boolean] Whether or not the code is a valid Ruby expression.
+    # @example
+    #   valid_expression?("class Hello") #=> false
+    #   valid_expression?("class Hello; end") #=> true
+    def valid_expression?(code)
+      !!Ripper::SexpBuilder.new(code).parse
+    end
+
+  else
+    require 'ruby_parser'
+
+    # Determine if a string of code is a valid Ruby expression.
+    # Ruby 1.9 uses Ripper, Ruby 1.8 uses RubyParser.
+    # @param [String] code The code to validate.
+    # @return [Boolean] Whether or not the code is a valid Ruby expression.
+    # @example
+    #   valid_expression?("class Hello") #=> false
+    #   valid_expression?("class Hello; end") #=> true
+    def valid_expression?(code)
+      RubyParser.new.parse(code)
+    rescue Racc::ParseError, SyntaxError
+      false
+    else
+      true
+    end
+  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 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