pry 0.6.7-i386-mingw32

data/lib/pry/pry_instance.rb

@@ -0,0 +1,316 @@
+class Pry
+
+  # The list of configuration options.
+  CONFIG_OPTIONS = [:input, :output, :commands, :print,
+                   :prompt, :hooks]
+
+  attr_accessor *CONFIG_OPTIONS
+
+  # 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={})
+
+    default_options = {}
+    CONFIG_OPTIONS.each { |v| default_options[v] = Pry.send(v) }
+    default_options.merge!(options)
+
+    CONFIG_OPTIONS.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 or an explictly given
+  #   return value. If given return value is `nil` or no return value
+  #   is specified then `target` will be returned.
+  # @example
+  #   Pry.new.repl(Object.new)
+  def repl(target=TOPLEVEL_BINDING)
+    target = Pry.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_data = 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
+
+    # If break_data is an array, then the last element is the return value
+    break_level, return_value = Array(break_data)
+    
+    # keep throwing until we reach the desired nesting level
+    if nesting_level != break_level
+      throw :breakout, break_data
+    end
+
+    # if one was provided, return the return value
+    return return_value if return_value
+    
+    # otherwise return the target_self
+    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 = Pry.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 = Pry.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 = Pry.binding_for(target)
+    eval_string = ""
+
+    loop do
+      current_prompt = select_prompt(eval_string.empty?, target.eval('self'))
+
+      val = readline(current_prompt)
+
+      # exit pry if we receive EOF character
+      if !val
+        output.puts
+        throw(:breakout, nesting.level) 
+      end
+      
+      val.chomp!
+
+      Pry.cmd_ret_value = process_commands(val, eval_string, target)
+
+      if Pry.cmd_ret_value
+        eval_string << "Pry.cmd_ret_value\n"
+      else
+        eval_string << "#{val}\n"
+      end
+
+      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, cmd_data = commands.commands.find do |name, cmd_data|
+      /^#{name}(?!\S)(?:\s+(.+))?/ =~ val
+    end
+
+    # no command was matched, so return to caller
+    return if !pattern
+    
+    args_string = $1
+    args = args_string ? Shellwords.shellwords(args_string) : []
+    action = cmd_data[:action]
+    keep_retval = cmd_data[:keep_retval]
+    
+    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
+      ret_value = 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)
+      ret_value = commands.instance_exec(*args_with_corrected_arity, &action)
+    end
+    
+    # a command was processed so we can now clear the input string
+    val.clear
+
+    # return value of block only if :keep_retval is true
+    ret_value if keep_retval
+  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
+end

data/lib/pry/version.rb

@@ -0,0 +1,3 @@
+class Pry
+  VERSION = "0.6.7"
+end

data/test/test.rb

@@ -0,0 +1,681 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'bacon'
+require "#{direc}/../lib/pry"
+require "#{direc}/test_helper"
+
+puts "Ruby Version #{RUBY_VERSION}"
+puts "Testing Pry #{Pry::VERSION}"
+puts "With method_source version #{MethodSource::VERSION}"
+puts "--"
+
+describe Pry do
+  describe "open a Pry session on an object" do
+    describe "rep" do
+      
+      before do
+        class Hello
+        end
+      end
+
+      after do
+        Object.send(:remove_const, :Hello)
+      end
+
+      it 'should set an ivar on an object' do
+        input_string = "@x = 10"
+        input = InputTester.new(input_string)
+        o = Object.new
+
+        pry_tester = Pry.new(:input => input, :output => Pry::NullOutput)
+        pry_tester.rep(o)
+        o.instance_variable_get(:@x).should == 10
+      end
+
+      it 'should make self evaluate to the receiver of the rep session' do
+        o = Object.new
+        str_output = StringIO.new
+        
+        pry_tester = Pry.new(:input => InputTester.new("self"), :output => str_output)
+        pry_tester.rep(o)
+        str_output.string.should =~ /#{o.to_s}/
+      end
+
+      it 'should work with multi-line input' do
+        o = Object.new
+        str_output = StringIO.new
+        
+        pry_tester = Pry.new(:input => InputTester.new("x = ", "1 + 4"), :output => str_output)
+        pry_tester.rep(o)
+        str_output.string.should =~ /5/
+      end
+
+      it 'should define a nested class under Hello and not on top-level or Pry' do
+        pry_tester = Pry.new(:input => InputTester.new("class Nested", "end"), :output => Pry::NullOutput)
+        pry_tester.rep(Hello)
+        Hello.const_defined?(:Nested).should == true
+      end
+    end
+
+    describe "repl" do
+      describe "basic functionality" do
+        it 'should set an ivar on an object and exit the repl' do
+          input_strings = ["@x = 10", "exit"]
+          input = InputTester.new(*input_strings)
+
+          o = Object.new
+
+          pry_tester = Pry.start(o, :input => input, :output => Pry::NullOutput)
+
+          o.instance_variable_get(:@x).should == 10
+        end
+
+        it 'should execute start session and end session hooks' do
+          input = InputTester.new("exit")
+          str_output = StringIO.new
+          o = Object.new
+          
+          pry_tester = Pry.start(o, :input => input, :output => str_output)
+          str_output.string.should =~ /Beginning.*#{o}/
+          str_output.string.should =~ /Ending.*#{o}/
+        end
+      end
+
+      describe "nesting" do
+        after do
+          Pry.reset_defaults
+        end
+        
+        it 'should nest properly' do
+          Pry.input = InputTester.new("pry", "pry", "pry", "\"nest:\#\{Pry.nesting.level\}\"", "exit_all")
+
+          str_output = StringIO.new
+          Pry.output = str_output
+
+          o = Object.new
+
+          pry_tester = o.pry
+          str_output.string.should =~ /nest:3/
+        end
+      end
+
+      describe "defining methods" do
+        it 'should define a method on the singleton class of an object when performing "def meth;end" inside the object' do
+          [Object.new, {}, []].each do |val|
+            str_input = StringIO.new("def hello;end")
+            Pry.new(:input => str_input, :output => StringIO.new).rep(val)
+            
+            val.methods(false).map(&:to_sym).include?(:hello).should == true
+          end
+        end
+
+        it 'should define an instance method on the module when performing "def meth;end" inside the module' do
+          str_input = StringIO.new("def hello;end")
+          hello = Module.new
+          Pry.new(:input => str_input, :output => StringIO.new).rep(hello)
+          hello.instance_methods(false).map(&:to_sym).include?(:hello).should == true
+        end
+
+        it 'should define an instance method on the class when performing "def meth;end" inside the class' do
+          str_input = StringIO.new("def hello;end")
+          hello = Class.new
+          Pry.new(:input => str_input, :output => StringIO.new).rep(hello)
+          hello.instance_methods(false).map(&:to_sym).include?(:hello).should == true
+        end
+
+        it 'should define a method on the class of an object when performing "def meth;end" inside an immediate value or Numeric' do
+          # should include  float in here, but test fails for some reason
+          # on 1.8.7, no idea why!
+          [:test, 0, true, false, nil].each do |val|
+            str_input = StringIO.new("def hello;end")
+            Pry.new(:input => str_input, :output => StringIO.new).rep(val)
+            val.class.instance_methods(false).map(&:to_sym).include?(:hello).should == true
+          end
+        end
+        
+      end        
+        
+
+      describe "commands" do
+        it 'should run a command with no parameter' do
+          pry_tester = Pry.new
+          pry_tester.commands = CommandTester
+          pry_tester.input = InputTester.new("command1", "exit_all")
+          pry_tester.commands = CommandTester
+
+          str_output = StringIO.new
+          pry_tester.output = str_output
+
+          pry_tester.rep
+
+          str_output.string.should =~ /command1/
+        end
+
+        it 'should run a command with one parameter' do
+          pry_tester = Pry.new
+          pry_tester.commands = CommandTester
+          pry_tester.input = InputTester.new("command2 horsey", "exit_all")
+          pry_tester.commands = CommandTester
+
+          str_output = StringIO.new
+          pry_tester.output = str_output
+
+          pry_tester.rep
+
+          str_output.string.should =~ /horsey/
+        end
+      end
+
+      describe "Object#pry" do
+
+        after do
+          Pry.reset_defaults
+        end
+        
+        it "should start a pry session on the receiver (first form)" do
+          Pry.input = InputTester.new("self", "exit")
+
+          str_output = StringIO.new
+          Pry.output = str_output
+
+          20.pry
+
+          str_output.string.should =~ /20/
+        end
+
+        it "should start a pry session on the receiver (second form)" do
+          Pry.input = InputTester.new("self", "exit")
+
+          str_output = StringIO.new
+          Pry.output = str_output
+
+          pry 20
+          
+          str_output.string.should =~ /20/
+        end
+
+        it "should error if more than one argument is passed to Object#pry" do
+          lambda { pry(20, :input => Readline) }.should.raise ArgumentError
+        end
+      end
+
+      describe "Pry.binding_for" do
+        it 'should return TOPLEVEL_BINDING if parameter self is main' do
+          _main_ = lambda { TOPLEVEL_BINDING.eval('self') }
+          Pry.binding_for(_main_.call).is_a?(Binding).should == true
+          Pry.binding_for(_main_.call).should == TOPLEVEL_BINDING
+          Pry.binding_for(_main_.call).should == Pry.binding_for(_main_.call)
+        end
+      end
+
+
+      describe "test Pry defaults" do
+
+        after do
+          Pry.reset_defaults
+        end
+        
+        describe "input" do
+
+          after do
+            Pry.reset_defaults
+          end
+          
+          it 'should set the input default, and the default should be overridable' do
+            Pry.input = InputTester.new("5")
+
+            str_output = StringIO.new
+            Pry.output = str_output
+            Pry.new.rep
+            str_output.string.should =~ /5/
+
+            Pry.new(:input => InputTester.new("6")).rep
+            str_output.string.should =~ /6/
+          end
+
+          it 'should pass in the prompt if readline arity is 1' do
+            Pry.prompt = proc { "A" }
+
+            arity_one_input = Class.new do
+              attr_accessor :prompt
+              def readline(prompt)
+                @prompt = prompt
+                "exit"
+              end
+            end.new
+
+            Pry.start(self, :input => arity_one_input, :output => Pry::NullOutput)
+            arity_one_input.prompt.should == Pry.prompt.call
+          end
+
+          it 'should not pass in the prompt if the arity is 0' do
+            Pry.prompt = proc { "A" }
+
+            arity_zero_input = Class.new do
+              def readline
+                "exit"
+              end
+            end.new
+
+            lambda { Pry.start(self, :input => arity_zero_input, :output => Pry::NullOutput) }.should.not.raise Exception
+          end
+
+          it 'should not pass in the prompt if the arity is -1' do
+            Pry.prompt = proc { "A" }
+
+            arity_multi_input = Class.new do
+              attr_accessor :prompt
+              
+              def readline(*args)
+                @prompt = args.first
+                "exit"
+              end
+            end.new
+
+            Pry.start(self, :input => arity_multi_input, :output => Pry::NullOutput)
+            arity_multi_input.prompt.should == nil
+          end
+          
+        end
+
+        it 'should set the output default, and the default should be overridable' do
+          Pry.input = InputTester.new("5", "6", "7")
+          
+          str_output = StringIO.new
+          Pry.output = str_output
+          
+          Pry.new.rep
+          str_output.string.should =~ /5/
+
+          Pry.new.rep
+          str_output.string.should =~ /5\n.*6/
+
+          str_output2 = StringIO.new
+          Pry.new(:output => str_output2).rep
+          str_output2.string.should.not =~ /5\n.*6/
+          str_output2.string.should =~ /7/
+        end
+
+        describe "Pry.run_command" do
+          before do
+            class RCTest
+              def a() end
+              B = 20
+              @x = 10
+            end
+          end
+
+          after do
+            Object.remove_const(:RCTest)
+          end
+          
+          it "should execute command in the appropriate object context" do
+            result = Pry.run_command "ls", :context => RCTest
+            result.map(&:to_sym).should == [:@x]
+          end
+
+          it "should execute command with parameters in the appropriate object context" do
+            result = Pry.run_command "ls -M", :context => RCTest
+            result.map(&:to_sym).should == [:a]
+          end
+
+          it "should execute command and show output with :show_output => true flag" do
+            str = StringIO.new
+            Pry.output = str
+            result = Pry.run_command "ls -av", :context => RCTest, :show_output => true
+            str.string.should =~ /global variables/
+            Pry.output = $stdout
+          end
+
+          it "should execute command with multiple parameters" do
+            result = Pry.run_command "ls -c -M RCTest"
+            result.map(&:to_sym).should == [:a, :B]
+          end
+        end
+
+        describe "commands" do
+          it 'should define a command that keeps its return value' do
+            class Command68 < Pry::CommandBase
+              command "hello", "", :keep_retval => true do
+                :kept_hello
+              end
+            end
+            str_output = StringIO.new
+            Pry.new(:input => StringIO.new("hello"), :output => str_output, :commands => Command68).rep
+            str_output.string.should =~ /:kept_hello/
+
+            Object.remove_const(:Command68)
+          end
+
+          it 'should define a command that does NOT keep its return value' do
+            class Command68 < Pry::CommandBase
+              command "hello", "", :keep_retval => false do
+                :kept_hello
+              end
+            end
+            str_output = StringIO.new
+            Pry.new(:input => StringIO.new("hello"), :output => str_output, :commands => Command68).rep
+            (str_output.string =~ /:kept_hello/).should == nil
+
+            Object.remove_const(:Command68)
+          end
+          
+          
+          it 'should set the commands default, and the default should be overridable' do
+            class Command0 < Pry::CommandBase
+              command "hello" do
+                output.puts "hello world"
+              end
+            end
+
+            Pry.commands = Command0
+
+            str_output = StringIO.new
+            Pry.new(:input => InputTester.new("hello"), :output => str_output).rep
+            str_output.string.should =~ /hello world/
+
+            class Command1 < Pry::CommandBase
+              command "goodbye", "" do
+                output.puts "goodbye world"
+              end
+            end
+
+            str_output = StringIO.new
+            
+            Pry.new(:input => InputTester.new("goodbye"), :output => str_output, :commands => Command1).rep
+            str_output.string.should =~ /goodbye world/
+
+            Object.remove_const(:Command0)
+            Object.remove_const(:Command1)
+          end
+
+          it 'should inherit "help" command from Pry::CommandBase' do
+            class Command2 < Pry::CommandBase
+              command "h", "h command" do
+              end
+            end
+
+            Command2.commands.keys.size.should == 2
+            Command2.commands.keys.include?("help").should == true
+            Command2.commands.keys.include?("h").should == true
+
+            Object.remove_const(:Command2)
+          end
+
+          it 'should inherit commands from Pry::Commands' do
+            class Command3 < Pry::Commands
+              command "v" do
+              end
+            end
+
+            Command3.commands.include?("nesting").should == true
+            Command3.commands.include?("jump-to").should == true
+            Command3.commands.include?("cd").should == true
+            Command3.commands.include?("v").should == true
+
+            Object.remove_const(:Command3)
+          end
+
+          it 'should alias a command with another command' do
+            class Command6 < Pry::CommandBase
+              alias_command "help2", "help"
+            end
+
+            Command6.commands["help2"].should == Command6.commands["help"]
+            # str_output = StringIO.new
+            # Pry.new(:input => InputTester.new("run_v"), :output => str_output, :commands => Command3).rep
+            # str_output.string.should =~ /v command/
+
+            Object.remove_const(:Command6)
+          end
+
+          it 'should change description of a command using desc' do
+            
+            class Command7 < Pry::Commands
+            end
+
+            orig = Command7.commands["help"][:description]
+
+            class Command7
+              desc "help", "blah"
+            end
+
+            Command7.commands["help"][:description].should.not == orig
+            Command7.commands["help"][:description].should == "blah"
+            
+            Object.remove_const(:Command7)
+          end
+          
+          it 'should run a command from within a command' do
+            class Command01 < Pry::Commands
+              command "v" do
+                output.puts "v command"
+              end
+
+              command "run_v" do
+                run "v"
+              end
+            end
+
+            str_output = StringIO.new
+            Pry.new(:input => InputTester.new("run_v"), :output => str_output, :commands => Command01).rep
+            str_output.string.should =~ /v command/
+
+            Object.remove_const(:Command01)
+          end
+
+          it 'should enable an inherited method to access opts and output and target, due to instance_exec' do
+            class Command3 < Pry::Commands
+              command "v" do
+                output.puts "#{target.eval('self')}"
+              end
+            end
+
+            class Command4 < Command3
+            end
+
+            str_output = StringIO.new
+            Pry.new(:print => proc {}, :input => InputTester.new("v"),
+                    :output => str_output, :commands => Command4).rep("john")
+            str_output.string.chomp.should == "john"
+
+            Object.remove_const(:Command3)
+            Object.remove_const(:Command4)
+          end
+
+          it 'should import commands from another command object' do
+            class Command3 < Pry::CommandBase
+              import_from Pry::Commands, "status", "jump-to"
+            end
+
+            str_output = StringIO.new
+            Pry.new(:print => proc {}, :input => InputTester.new("status"),
+                    :output => str_output, :commands => Command3).rep("john")
+            str_output.string.should =~ /Status:/
+
+            Object.remove_const(:Command3)
+          end
+
+          it 'should delete some inherited commands when using delete method' do
+            class Command3 < Pry::Commands
+              command "v" do
+              end
+              
+              delete "show_doc", "show_method"
+              delete "ls"
+            end
+
+            Command3.commands.include?("nesting").should == true
+            Command3.commands.include?("jump-to").should == true
+            Command3.commands.include?("cd").should == true
+            Command3.commands.include?("v").should == true
+            Command3.commands.include?("show_doc").should == false
+            Command3.commands.include?("show_method").should == false
+            Command3.commands.include?("ls").should == false
+
+            Object.remove_const(:Command3)
+          end
+
+          it 'should override some inherited commands' do
+            class Command3 < Pry::Commands
+              command "jump-to" do
+                output.puts "jump-to the music"
+              end
+
+              command "help" do
+                output.puts "help to the music"
+              end
+            end
+
+            # suppress evaluation output
+            Pry.print = proc {}
+            
+            str_output = StringIO.new
+            Pry.new(:input => InputTester.new("jump-to"), :output => str_output, :commands => Command3).rep
+            str_output.string.chomp.should == "jump-to the music"
+
+            str_output = StringIO.new
+            Pry.new(:input => InputTester.new("help"), :output => str_output, :commands => Command3).rep
+            str_output.string.chomp.should == "help to the music"
+            
+            Object.remove_const(:Command3)
+
+            Pry.reset_defaults
+          end
+        end
+
+        it "should set the print default, and the default should be overridable" do
+          new_print = proc { |out, value| out.puts value }
+          Pry.print =  new_print
+
+          Pry.new.print.should == Pry.print
+          str_output = StringIO.new
+          Pry.new(:input => InputTester.new("\"test\""), :output => str_output).rep
+          str_output.string.should == "test\n"
+
+          str_output = StringIO.new
+          Pry.new(:input => InputTester.new("\"test\""), :output => str_output,
+                  :print => proc { |out, value| out.puts value.reverse }).rep
+          str_output.string.should == "tset\n"
+          
+          Pry.new.print.should == Pry.print
+          str_output = StringIO.new
+          Pry.new(:input => InputTester.new("\"test\""), :output => str_output).rep
+          str_output.string.should == "test\n"
+        end
+
+        describe "pry return values" do
+          it 'should return the target object' do
+            Pry.start(self, :input => StringIO.new("exit"), :output => Pry::NullOutput).should == self
+          end
+
+          it 'should return the parameter given to exit' do
+            Pry.start(self, :input => StringIO.new("exit 10"), :output => Pry::NullOutput).should == 10
+          end
+
+          it 'should return the parameter (multi word string) given to exit' do
+            Pry.start(self, :input => StringIO.new("exit \"john mair\""), :output => Pry::NullOutput).should == "john mair"
+          end
+
+          it 'should return the parameter (function call) given to exit' do
+            Pry.start(self, :input => StringIO.new("exit 'abc'.reverse"), :output => Pry::NullOutput).should == 'cba'
+          end
+
+          it 'should return the parameter (self) given to exit' do
+            Pry.start("carl", :input => StringIO.new("exit self"), :output => Pry::NullOutput).should == "carl"
+          end
+        end
+        
+        describe "prompts" do
+          it 'should set the prompt default, and the default should be overridable (single prompt)' do
+            new_prompt = proc { "test prompt> " }
+            Pry.prompt =  new_prompt
+
+            Pry.new.prompt.should == Pry.prompt
+            Pry.new.select_prompt(true, 0).should == "test prompt> "
+            Pry.new.select_prompt(false, 0).should == "test prompt> "
+
+            new_prompt = proc { "A" }
+            pry_tester = Pry.new(:prompt => new_prompt)
+            pry_tester.prompt.should == new_prompt
+            pry_tester.select_prompt(true, 0).should == "A"
+            pry_tester.select_prompt(false, 0).should == "A"
+                                 
+            Pry.new.prompt.should == Pry.prompt
+            Pry.new.select_prompt(true, 0).should == "test prompt> "
+            Pry.new.select_prompt(false, 0).should == "test prompt> "
+          end
+
+          it 'should set the prompt default, and the default should be overridable (multi prompt)' do
+            new_prompt = [proc { "test prompt> " }, proc { "test prompt* " }]
+            Pry.prompt =  new_prompt
+
+            Pry.new.prompt.should == Pry.prompt
+            Pry.new.select_prompt(true, 0).should == "test prompt> "
+            Pry.new.select_prompt(false, 0).should == "test prompt* "
+
+            new_prompt = [proc { "A" }, proc { "B" }]
+            pry_tester = Pry.new(:prompt => new_prompt)
+            pry_tester.prompt.should == new_prompt
+            pry_tester.select_prompt(true, 0).should == "A"
+            pry_tester.select_prompt(false, 0).should == "B"
+                                 
+            Pry.new.prompt.should == Pry.prompt
+            Pry.new.select_prompt(true, 0).should == "test prompt> "
+            Pry.new.select_prompt(false, 0).should == "test prompt* "
+          end
+        end
+
+        it 'should set the hooks default, and the default should be overridable' do
+          Pry.input = InputTester.new("exit")
+          Pry.hooks = {
+            :before_session => proc { |out,_| out.puts "HELLO" },
+            :after_session => proc { |out,_| out.puts "BYE" }
+          }
+          
+          str_output = StringIO.new
+          Pry.new(:output => str_output).repl
+          str_output.string.should =~ /HELLO/
+          str_output.string.should =~ /BYE/
+          
+          Pry.input.rewind
+
+          str_output = StringIO.new
+          Pry.new(:output => str_output,
+                  :hooks => {
+                    :before_session => proc { |out,_| out.puts "MORNING" },
+                    :after_session => proc { |out,_| out.puts "EVENING" }
+                  }
+                  ).repl
+
+          str_output.string.should =~ /MORNING/
+          str_output.string.should =~ /EVENING/
+
+          # try below with just defining one hook
+          Pry.input.rewind
+          str_output = StringIO.new
+          Pry.new(:output => str_output,
+                  :hooks => {
+                    :before_session => proc { |out,_| out.puts "OPEN" }
+                  }
+                  ).repl
+          
+          str_output.string.should =~ /OPEN/
+
+          Pry.input.rewind
+          str_output = StringIO.new
+          Pry.new(:output => str_output,
+                  :hooks => {
+                    :after_session => proc { |out,_| out.puts "CLOSE" }
+                  }
+                  ).repl
+
+          str_output.string.should =~ /CLOSE/
+
+          Pry.reset_defaults
+        end
+      end
+    end
+  end
+end