pry 0.3.0 → 0.4.0pre1

data/lib/pry.rb

@@ -4,254 +4,17 @@
 direc = File.dirname(__FILE__)
 
 require "method_source"
+require "readline"
 require "#{direc}/pry/version"
-require "#{direc}/pry/input"
-require "#{direc}/pry/output"
+require "#{direc}/pry/hooks"
+require "#{direc}/pry/print"
+require "#{direc}/pry/command_base"
+require "#{direc}/pry/commands"
+require "#{direc}/pry/prompts"
+require "#{direc}/pry/completion"
+require "#{direc}/pry/core_extensions"
+require "#{direc}/pry/pry_class"
+require "#{direc}/pry/pry_instance"
 
-class Pry
-  def self.start(target=TOPLEVEL_BINDING)
-    new.repl(target)
-  end
 
-  def self.view(obj)
-    case obj
-    when String, Array, Hash, Symbol, nil
-      obj.inspect
-    else
-      obj.to_s
-    end
-  end
 
-  # class accessors
-  class << self
-    attr_reader :nesting
-    attr_accessor :last_result
-    attr_accessor :default_prompt, :wait_prompt
-  end
-
-  self.default_prompt = proc do |v, nest|
-    if nest == 0
-      "pry(#{Pry.view(v)})> "
-    else
-      "pry(#{Pry.view(v)}):#{Pry.view(nest)}> "
-    end
-  end
-  
-  self.wait_prompt = proc do |v, nest|
-    if nest == 0
-      "pry(#{Pry.view(v)})* "
-    else
-      "pry(#{Pry.view(v)}):#{Pry.view(nest)}* "
-    end
-  end
-
-  attr_accessor :input, :output
-  attr_accessor :default_prompt, :wait_prompt
-  attr_reader :last_result
-  
-  def initialize(input = Input.new, output = Output.new)
-    @input = input
-    @output = output
-
-    @default_prompt = Pry.default_prompt
-    @wait_prompt = Pry.wait_prompt
-  end
-
-  @nesting = []
-
-  def @nesting.level
-    last.is_a?(Array) ? last.first : nil
-  end
-
-  def nesting
-    self.class.nesting
-  end
-
-  def nesting=(v)
-    self.class.nesting = v
-  end
-  
-  # loop
-  def repl(target=TOPLEVEL_BINDING)
-    target = binding_for(target)
-    target_self = target.eval('self')
-    output.session_start(target_self)
-
-    nesting_level = nesting.size
-
-    # Make sure _ exists
-    target.eval("_ = Pry.last_result")
-    
-    break_level = catch(:breakout) do
-      nesting << [nesting.size, target_self]
-      loop do
-        rep(target) 
-      end
-    end
-
-    nesting.pop
-    output.session_end(target_self)
-
-    # we only enter here if :breakout has been thrown
-    if nesting_level != break_level
-      throw :breakout, break_level 
-    end
-    
-    target_self
-  end
-  
-  # print
-  def rep(target=TOPLEVEL_BINDING)
-    target = binding_for(target)
-    output.print re(target)
-  end
-
-  # eval
-  def re(target=TOPLEVEL_BINDING)
-    target = binding_for(target)
-    Pry.last_result = target.eval r(target)
-    target.eval("_ = Pry.last_result")
-  rescue SystemExit => e
-    exit
-  rescue Exception => e
-    e
-  end
-
-  # read
-  def r(target=TOPLEVEL_BINDING)
-    target = binding_for(target)
-    eval_string = ""
-    loop do
-      val = input.read(prompt(eval_string, target, nesting.level))
-      eval_string += "#{val.chomp}\n"
-      process_commands(val, eval_string, target)
-      
-      break eval_string if valid_expression?(eval_string)
-    end
-  end
-  
-  def process_commands(val, eval_string, target)
-    def eval_string.clear() replace("") end
-    
-    case val
-    when "exit_program", "quit_program"
-      output.exit_program
-      exit
-    when "!"
-      output.refresh
-      eval_string.clear
-    when "help"
-      output.show_help
-      eval_string.clear
-    when "nesting"
-      output.show_nesting(nesting)
-      eval_string.clear
-    when "status"
-      output.show_status(nesting, target)
-      eval_string.clear
-    when "exit_all"
-      throw(:breakout, 0)
-    when "exit", "quit", "back", /^cd\s*\.\./
-      output.exit
-      throw(:breakout, nesting.level)
-    when "ls"
-      output.ls(target)
-      eval_string.clear
-    when /^cat\s+(.+)/
-      var = $~.captures.first
-      output.cat(target, var)
-      eval_string.clear
-    when /^cd\s+(.+)/
-      obj = $~.captures.first
-      target.eval("#{obj}.pry")
-      eval_string.clear
-    when /^show_doc\s*(.+)/
-      meth_name = ($~.captures).first
-      doc = target.eval("method(:#{meth_name})").comment
-      output.show_doc doc
-      eval_string.clear
-    when /^show_idoc\s*(.+)/
-      meth_name = ($~.captures).first
-      doc = target.eval("instance_method(:#{meth_name})").comment
-      output.show_doc doc
-      eval_string.clear
-    when /^show_method\s*(.+)/
-      meth_name = ($~.captures).first
-      code = target.eval("method(:#{meth_name})").source
-      output.show_method code
-      eval_string.clear
-    when /^show_instance_method\s*(.+)/, /^show_imethod\s*(.+)/
-      meth_name = ($~.captures).first
-      code = target.eval("instance_method(:#{meth_name})").source
-      output.show_method code
-      eval_string.clear
-    when /^jump_to\s*(\d*)/
-      break_level = ($~.captures).first.to_i
-      output.jump_to(break_level)
-
-      case break_level
-      when nesting.level
-        output.warn_already_at_level(nesting.level)
-        eval_string.clear
-      when (0...nesting.level)
-        throw(:breakout, break_level + 1)
-      else
-        output.err_invalid_nest_level(break_level,
-                                      nesting.level - 1)
-        eval_string.clear
-      end
-    end
-  end
-
-  def prompt(eval_string, target, nest)
-    target_self = target.eval('self')
-    
-    if eval_string.empty?
-      default_prompt.call(target_self, nest)
-    else
-      wait_prompt.call(target_self, nest)
-    end
-  end
-
-  if RUBY_VERSION =~ /1.9/
-    require 'ripper'
-    
-    def valid_expression?(code)
-      !!Ripper::SexpBuilder.new(code).parse
-    end
-    
-  else
-    require 'ruby_parser'
-    
-    def valid_expression?(code)
-      RubyParser.new.parse(code)
-    rescue Racc::ParseError, SyntaxError
-      false
-    else
-      true
-    end
-    
-  end
-
-  def binding_for(target)
-    if target.is_a?(Binding)
-      target
-    else
-      if target == TOPLEVEL_BINDING.eval('self')
-        TOPLEVEL_BINDING
-      else
-        target.instance_eval { binding }
-      end
-    end
-  end
-
-  module ObjectExtensions
-    def pry(target=self)
-      Pry.start(target)
-    end
-  end
-end
-
-class Object
-  include Pry::ObjectExtensions
-end

data/lib/pry/command_base.rb

@@ -0,0 +1,114 @@
+class Pry
+
+  # Basic command functionality. All user-defined commands must
+  # inherit from this class. It provides the `command` method.
+  class CommandBase
+    class << self
+      attr_accessor :commands
+      attr_accessor :command_info
+      attr_accessor :opts, :output, :target
+
+      # private because we want to force function style invocation. We require
+      # that the location where the block is defined has the `opts`
+      # method in scope.
+      private
+      
+      # Defines a new Pry command.
+      # @param [String, Array] names The name of the command (or array of
+      #   command name aliases).
+      # @param [String] description A description of the command.
+      # @yield The action to perform. The parameters in the block
+      #   determines the parameters the command will receive. All
+      #   parameters passed into the block will be strings. Successive
+      #   command parameters are separated by whitespace at the Pry prompt.
+      # @example
+      #   class MyCommands < Pry::CommandBase
+      #     command "greet", "Greet somebody" do |name|
+      #       puts "Good afternoon #{name.capitalize}!"
+      #     end
+      #   end
+      #
+      #   # From pry:
+      #   # pry(main)> _pry_.commands = MyCommands
+      #   # pry(main)> greet john
+      #   # Good afternoon John!
+      #   # pry(main)> help greet
+      #   # Greet somebody
+      def command(names, description="No description.", &block)
+        @commands ||= {}
+
+        Array(names).each do |name|
+          commands[name] = { :description => description, :action => block }
+        end
+      end
+
+      # Delete a command or an array of commands.
+      # Useful when inheriting from another command set and pruning
+      # those commands down to the ones you want.
+      # @param [Array<String>] names The command name or array
+      #   of command names you want to delete
+      # @example Deleteing inherited commands
+      #   class MyCommands < Pry::Commands
+      #     delete "show_method", "show_imethod", "show_doc", "show_idoc"
+      #   end
+      #   Pry.commands = MyCommands
+      def delete(*names)
+        names.each { |name| commands.delete(name) }
+      end
+
+      # Execute a command (this enables commands to call other commands).
+      # @param [String] name The command to execute
+      # @param [Array] args The parameters to pass to the command.
+      # @example Wrap one command with another
+      #   class MyCommands < Pry::Commands
+      #     command "ls2" do
+      #       output.puts "before ls"
+      #       run "ls"
+      #       output.puts "after ls"
+      #     end
+      #   end
+      def run(name, *args)
+        action = opts[:commands][name][:action]
+        instance_exec(*args, &action)
+      end
+
+      # Import commands from another command object.
+      # @param [Pry::CommandBase] klass The class to import from (must
+      #   be a subclass of `Pry::CommandBase`)
+      # @param [Array<String>] names The commands to import.
+      # @example
+      #   class MyCommands < Pry::CommandBase
+      #     import_from Pry::Commands, "ls", "show_method", "cd"
+      #   end
+      def import_from(klass, *names)
+        imported_hash = Hash[klass.commands.select { |k, v| names.include?(k) }]
+        commands.merge!(imported_hash)
+      end
+    end
+    
+    command "help", "This menu." do |cmd|
+      command_info = opts[:commands]
+      param = cmd
+
+      if !param
+        output.puts "Command list:"
+        output.puts "--"
+        command_info.each do |k, data|
+          output.puts "#{k}".ljust(18) + data[:description] if !data[:description].empty?
+        end
+      else
+        if command_info[param]
+          output.puts command_info[param][:description]
+        else
+          output.puts "No info for command: #{param}"
+        end
+      end
+    end
+
+    # Ensures that commands can be inherited
+    def self.inherited(klass)
+      klass.commands = commands.dup
+    end
+    
+  end
+end

data/lib/pry/commands.rb

@@ -0,0 +1,115 @@
+direc = File.dirname(__FILE__)
+require "#{direc}/command_base"
+
+class Pry
+
+  # Default commands used by Pry.
+  class Commands < CommandBase
+    
+    command "!", "Refresh the REPL" do
+      output.puts "Refreshed REPL"
+      opts[:eval_string].clear
+    end
+
+    command "!pry", "Start a Pry session on current self; this even works mid-expression." do
+      Pry.start(target)
+    end
+
+    command ["exit_program", "quit_program"], "End the current program." do
+      exit
+    end
+
+    command "nesting", "Show nesting information." do 
+      out = output
+      nesting = opts[:nesting]
+      
+      out.puts "Nesting status:"
+      out.puts "--"
+      nesting.each do |level, obj|
+        if level == 0
+          out.puts "#{level}. #{Pry.view(obj)} (Pry top level)"
+        else
+          out.puts "#{level}. #{Pry.view(obj)}"
+        end
+      end
+    end
+
+    command "status", "Show status information." do
+      out = output
+      nesting = opts[:nesting]
+      
+      out.puts "Status:"
+      out.puts "--"
+      out.puts "Receiver: #{Pry.view(target.eval('self'))}"
+      out.puts "Nesting level: #{nesting.level}"
+      out.puts "Local variables: #{Pry.view(target.eval('local_variables'))}"
+      out.puts "Pry instance: #{Pry.active_instance}"
+      out.puts "Last result: #{Pry.view(Pry.last_result)}"
+    end
+
+    command "exit_all", "End all nested Pry sessions." do
+      throw(:breakout, 0) 
+    end
+
+    command "ls", "Show the list of vars in the current scope." do
+      output.puts "#{Pry.view(target.eval('local_variables + instance_variables'))}"
+    end
+
+    command "cat", "Show output of <var>.inspect." do |obj|
+      out = output
+      out.puts target.eval("#{obj}.inspect")
+    end
+    
+    command "cd", "Start a Pry session on <var> (use `cd ..` to go back)" do |obj|
+      throw(:breakout, opts[:nesting].level) if obj == ".."
+      target.eval("#{obj}.pry")
+    end
+
+    command "show_doc", "Show the comments above <methname>" do |meth_name|
+      doc = target.eval("method(:#{meth_name})").comment
+      output.puts doc
+    end
+
+    command "show_idoc", "Show the comments above instance method <methname>" do |meth_name|
+      doc = target.eval("instance_method(:#{meth_name})").comment
+      output.puts doc
+    end
+
+    command "show_method", "Show sourcecode for method <methname>." do |meth_name|
+      doc = target.eval("method(:#{meth_name})").source
+      output.puts doc
+    end
+
+    command "show_imethod", "Show sourcecode for instance method <methname>." do |meth_name|
+      doc = target.eval("instance_method(:#{meth_name})").source
+      output.puts doc
+    end
+
+    command "jump_to", "Jump to a Pry session further up the stack, exiting all sessions below." do |break_level|
+      break_level = break_level.to_i
+      nesting = opts[:nesting]
+
+      case break_level
+      when nesting.level
+        output.puts "Already at nesting level #{nesting.level}"
+      when (0...nesting.level)
+        throw(:breakout, break_level + 1)
+      else
+        max_nest_level = nesting.level - 1
+        output.puts "Invalid nest level. Must be between 0 and #{max_nest_level}. Got #{break_level}."
+      end
+    end
+
+    command "ls_methods", "List all methods defined on class of receiver." do
+      output.puts "#{Pry.view(target.eval('public_methods(false) + private_methods(false) + protected_methods(false)'))}"
+    end
+
+    command "ls_imethods", "List all instance methods defined on class of receiver." do
+      output.puts "#{Pry.view(target.eval('public_instance_methods(false) + private_instance_methods(false) + protected_instance_methods(false)'))}"
+    end
+
+    command ["exit", "quit", "back"], "End the current Pry session." do
+      throw(:breakout, opts[:nesting].level)
+    end
+  end
+end