pry 0.10.pre.1-i386-mswin32 → 0.10.0.pre3-i386-mswin32

data/test/test_pry_output.rb

@@ -1,41 +0,0 @@
-require 'helper'
-
-describe Pry do
-  describe "output failsafe" do
-    after do
-      Pry.config.print = Pry::DEFAULT_PRINT
-    end
-
-    it "should catch serialization exceptions" do
-      Pry.config.print = lambda { |*a| raise "catch-22" }
-
-      lambda {
-        mock_pry("1")
-      }.should.not.raise
-    end
-
-    it "should display serialization exceptions" do
-      Pry.config.print = lambda { |*a| raise "catch-22" }
-
-      mock_pry("1").should =~ /\(pry\) output error: #<RuntimeError: catch-22>/
-    end
-
-    it "should catch errors serializing exceptions" do
-      Pry.config.print = lambda do |*a|
-        raise Exception.new("catch-22").tap{ |e| class << e; def inspect; raise e; end; end }
-      end
-
-      mock_pry("1").should =~ /\(pry\) output error: failed to show result/
-    end
-  end
-
-  describe "DEFAULT_PRINT" do
-    it "should output the right thing" do
-      mock_pry("{:a => 1}").should =~ /\{:a=>1\}/
-    end
-
-    it "should not be phased by un-inspectable things" do
-      mock_pry("class NastyClass; undef pretty_inspect; end", "NastyClass.new").should =~ /#<NastyClass:0x.*?>/
-    end
-  end
-end

data/test/test_sticky_locals.rb

@@ -1,155 +0,0 @@
-require 'helper'
-
-describe "Sticky locals (_file_ and friends)" do
-  it 'locals should all exist upon initialization' do
-    mock_pry("_file_").should.not =~ /NameError/
-    mock_pry("_dir_").should.not =~ /NameError/
-    mock_pry("_ex_").should.not =~ /NameError/
-    mock_pry("_pry_").should.not =~ /NameError/
-    mock_pry("_").should.not =~ /NameError/
-  end
-
-  it 'locals should still exist after cd-ing into a new context' do
-    mock_pry("cd 0", "_file_").should.not =~ /NameError/
-    mock_pry("cd 0","_dir_").should.not =~ /NameError/
-    mock_pry("cd 0","_ex_").should.not =~ /NameError/
-    mock_pry("cd 0","_pry_").should.not =~ /NameError/
-    mock_pry("cd 0","_").should.not =~ /NameError/
-  end
-
-  it 'locals should keep value after cd-ing(_pry_ and _ex_)' do
-    mock_pry("$x = _pry_;", "cd 0", "_pry_ == $x").should =~ /true/
-    mock_pry("error blah;", "$x = _ex_;", "cd 0", "_ex_ == $x").should =~ /true/
-  end
-
-  it 'locals should keep value after cd-ing (_file_ and _dir_)' do
-    Pry.commands.command "file-and-dir-test" do
-      set_file_and_dir_locals("/blah/ostrich.rb")
-    end
-
-    mock_pry("file-and-dir-test", "cd 0", "_file_").should =~ /\/blah\/ostrich\.rb/
-    a = mock_pry("file-and-dir-test", "cd 0", "_dir_").should =~ /\/blah/
-    Pry.commands.delete "file-and-dir-test"
-  end
-
-  describe "User defined sticky locals" do
-    describe "setting as Pry.config option" do
-      it 'should define a new sticky local for the session (normal value)' do
-        Pry.config.extra_sticky_locals[:test_local] = :john
-
-        o = Object.new
-        redirect_pry_io(InputTester.new("@value = test_local",
-                                        "exit-all")) do
-          Pry.start(o)
-        end
-
-        o.instance_variable_get(:@value).should == :john
-        Pry.config.extra_sticky_locals = {}
-      end
-
-      it 'should define a new sticky local for the session (proc)' do
-        Pry.config.extra_sticky_locals[:test_local] = proc { :john }
-
-        o = Object.new
-        redirect_pry_io(InputTester.new("@value = test_local",
-                                        "exit-all")) do
-          Pry.start(o)
-        end
-
-        o.instance_variable_get(:@value).should == :john
-        Pry.config.extra_sticky_locals = {}
-      end
-
-    end
-
-    describe "passing in as hash option when creating pry instance" do
-      it 'should define a new sticky local for the session (normal value)' do
-        o = Object.new
-        redirect_pry_io(InputTester.new("@value = test_local",
-                                        "exit-all")) do
-          Pry.start(o, :extra_sticky_locals => { :test_local => :john } )
-        end
-
-        o.instance_variable_get(:@value).should == :john
-      end
-
-      it 'should define multiple sticky locals' do
-        o = Object.new
-        redirect_pry_io(InputTester.new("@value1 = test_local1",
-                                        "@value2 = test_local2",
-                                        "exit-all")) do
-          Pry.start(o, :extra_sticky_locals => { :test_local1 => :john ,
-                      :test_local2 => :carl} )
-        end
-
-        o.instance_variable_get(:@value1).should == :john
-        o.instance_variable_get(:@value2).should == :carl
-      end
-
-
-      it 'should define a new sticky local for the session (as Proc)' do
-        o = Object.new
-        redirect_pry_io(InputTester.new("@value = test_local",
-                                        "exit-all")) do
-          Pry.start(o, :extra_sticky_locals => { :test_local => proc { :john }} )
-        end
-
-        o.instance_variable_get(:@value).should == :john
-      end
-    end
-
-    describe "hash option value should override config value" do
-      it 'should define a new sticky local for the session (normal value)' do
-        Pry.config.extra_sticky_locals[:test_local] = :john
-
-        o = Object.new
-        redirect_pry_io(InputTester.new("@value = test_local",
-                                        "exit-all")) do
-          Pry.start(o, :extra_sticky_locals => { :test_local => :carl })
-        end
-
-        o.instance_variable_get(:@value).should == :carl
-        Pry.config.extra_sticky_locals = {}
-      end
-    end
-
-    it 'should create a new sticky local' do
-      o = Object.new
-      pi = Pry.new
-      pi.add_sticky_local(:test_local) { :test_value }
-      pi.input, pi.output = InputTester.new("@value = test_local", "exit-all"), StringIO.new
-      pi.repl(o)
-
-      o.instance_variable_get(:@value).should == :test_value
-    end
-
-    it 'should still exist after cd-ing into new binding' do
-      o = Object.new
-      o2 = Object.new
-      o.instance_variable_set(:@o2, o2)
-      pi = Pry.new
-      pi.add_sticky_local(:test_local) { :test_value }
-      pi.input = InputTester.new("cd @o2\n",
-                                 "@value = test_local", "exit-all")
-      pi.output = StringIO.new
-      pi.repl(o)
-
-      o2.instance_variable_get(:@value).should == :test_value
-    end
-
-    it 'should provide different values for successive block invocations' do
-      o = Object.new
-      pi = Pry.new
-      v = [1, 2]
-      pi.add_sticky_local(:test_local) { v.shift }
-      pi.input = InputTester.new("@value1 = test_local",
-                                 "@value2 = test_local", "exit-all")
-      pi.output = StringIO.new
-      pi.repl(o)
-
-      o.instance_variable_get(:@value1).should == 1
-      o.instance_variable_get(:@value2).should == 2
-    end
-  end
-
-end

data/test/test_syntax_checking.rb

@@ -1,65 +0,0 @@
-require 'helper'
-
-describe Pry do
-  before do
-    @str_output = StringIO.new
-  end
-
-  [
-    ["p = '", "'"],
-    ["def", "a", "(); end"],
-    ["p = <<FOO", "lots", "and", "lots of", "foo", "FOO"],
-    ["[", ":lets,", "'list',", "[/nested/", "], things ]"],
-    ["abc =~ /hello", "/"],
-    ["issue = %W/", "343/"],
-    ["pouts(<<HI, 'foo", "bar", "HI", "baz')"],
-  ].each do |foo|
-    it "should not raise an error on broken lines: #{foo.join("\\n")}" do
-      redirect_pry_io(InputTester.new(*foo), @str_output) do
-        Pry.start
-      end
-
-      @str_output.string.should.not =~ /SyntaxError/
-    end
-  end
-
-  [
-    ["end"],
-    ["puts )("],
-    ["1 1"],
-    ["puts :"]
-  ] + (Pry::Helpers::BaseHelpers.rbx? ? [] : [
-    ["def", "method(1"], # in this case the syntax error is "expecting ')'".
-    ["o = Object.new.tap{ def o.render;","'MEH'", "}"] # in this case the syntax error is "expecting keyword_end".
-  ]).compact.each do |foo|
-    it "should raise an error on invalid syntax like #{foo.inspect}" do
-      redirect_pry_io(InputTester.new(*foo), @str_output) do
-        Pry.start
-      end
-
-      @str_output.string.should =~ /SyntaxError/
-    end
-  end
-
-  it "should not intefere with syntax errors explicitly raised" do
-    redirect_pry_io(InputTester.new(%q{raise SyntaxError, "unexpected $end"}), @str_output) do
-      Pry.start
-    end
-
-    @str_output.string.should =~ /SyntaxError/
-  end
-
-  it "should allow trailing , to continue the line" do
-    pry = Pry.new
-    Pry::Code.complete_expression?("puts 1, 2,").should == false
-  end
-
-  it "should complete an expression that contains a line ending with a ," do
-    pry = Pry.new
-    Pry::Code.complete_expression?("puts 1, 2,\n3").should == true
-  end
-
-  it "should not clobber _ex_ on a SyntaxError in the repl" do
-    mock_pry("raise RuntimeError, 'foo';", "puts foo)", "_ex_.is_a?(RuntimeError)").should =~ /^RuntimeError.*\nSyntaxError.*\n=> true/m
-  end
-end

data/test/test_wrapped_module.rb

@@ -1,174 +0,0 @@
-require 'helper'
-
-describe Pry::WrappedModule do
-
-  describe "#initialize" do
-    it "should raise an exception when a non-module is passed" do
-      lambda{ Pry::WrappedModule.new(nil) }.should.raise ArgumentError
-    end
-  end
-
-  describe "candidates" do
-    before do
-      class Host
-        source_files = [File.join(File.dirname(__FILE__), "candidate_helper1.rb"),
-                        File.join(File.dirname(__FILE__), "candidate_helper2.rb")]
-
-        source_files.each do |file|
-          binding.eval File.read(file), file, 1
-        end
-
-        # rank 2
-        class CandidateTest
-          def test6
-          end
-        end
-
-        class ForeverAlone
-        end
-      end
-    end
-
-    describe "number_of_candidates" do
-      it 'should return the correct number of candidates' do
-        Pry::WrappedModule(Host::CandidateTest).number_of_candidates.should == 3
-      end
-
-      it 'should return 0 candidates for a class with no methods and no other definitions' do
-        Pry::WrappedModule(Host::ForeverAlone).number_of_candidates.should == 0
-      end
-    end
-
-    describe "ordering of candidates" do
-      it 'should return class with largest number of methods as primary candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(0).file.should =~ /helper1/
-      end
-
-      it 'should return class with second largest number of methods as second ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(1).file.should =~ /helper2/
-      end
-
-      it 'should return class with third largest number of methods as third ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(2).file.should =~ /#{__FILE__}/
-      end
-
-      it 'should raise when trying to access non-existent candidate' do
-        lambda { Pry::WrappedModule(Host::CandidateTest).candidate(3) }.should.raise Pry::CommandError
-      end
-    end
-
-    describe "source_location" do
-      it 'should return primary candidates source_location by default' do
-        wm = Pry::WrappedModule(Host::CandidateTest)
-        wm.source_location.should == wm.candidate(0).source_location
-      end
-
-      it 'should return nil if no source_location can be found' do
-        Pry::WrappedModule(Host::ForeverAlone).source_location.should == nil
-      end
-    end
-
-    describe "source" do
-      it 'should return primary candidates source by default' do
-        wm = Pry::WrappedModule(Host::CandidateTest)
-        wm.source.should == wm.candidate(0).source
-      end
-
-      it 'should return source for highest ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(0).source.should =~ /test1/
-      end
-
-      it 'should return source for second ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(1).source.should =~ /test4/
-      end
-
-      it 'should return source for third ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(2).source.should =~ /test6/
-      end
-    end
-
-    describe "doc" do
-      it 'should return primary candidates doc by default' do
-        wm = Pry::WrappedModule(Host::CandidateTest)
-        wm.doc.should == wm.candidate(0).doc
-      end
-
-      it 'should return doc for highest ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(0).doc.should =~ /rank 0/
-      end
-
-      it 'should return doc for second ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(1).doc.should =~ /rank 1/
-      end
-
-      it 'should return doc for third ranked candidate' do
-        Pry::WrappedModule(Host::CandidateTest).candidate(2).doc.should =~ /rank 2/
-      end
-    end
-
-    after do
-      Object.remove_const(:Host)
-    end
-  end
-
-  describe ".method_prefix" do
-    before do
-      Foo = Class.new
-      @foo = Foo.new
-    end
-
-    after do
-      Object.remove_const(:Foo)
-    end
-
-    it "should return Foo# for normal classes" do
-      Pry::WrappedModule.new(Foo).method_prefix.should == "Foo#"
-    end
-
-    it "should return Bar# for modules" do
-      Pry::WrappedModule.new(Kernel).method_prefix.should == "Kernel#"
-    end
-
-    it "should return Foo. for singleton classes of classes" do
-      Pry::WrappedModule.new(class << Foo; self; end).method_prefix.should == "Foo."
-    end
-
-    describe "of singleton classes of objects" do
-      Pry::WrappedModule.new(class << @foo; self; end).method_prefix.should == "self."
-    end
-
-    describe "of anonymous classes should not be empty" do
-      Pry::WrappedModule.new(Class.new).method_prefix.should =~ /#<Class:.*>#/
-    end
-
-    describe "of singleton classes of anonymous classes should not be empty" do
-      Pry::WrappedModule.new(class << Class.new; self; end).method_prefix.should =~ /#<Class:.*>./
-    end
-  end
-
-  describe ".singleton_class?" do
-    it "should be true for singleton classes" do
-      Pry::WrappedModule.new(class << ""; self; end).singleton_class?.should == true
-    end
-
-    it "should be false for normal classes" do
-      Pry::WrappedModule.new(Class.new).singleton_class?.should == false
-    end
-
-    it "should be false for modules" do
-      Pry::WrappedModule.new(Module.new).singleton_class?.should == false
-    end
-  end
-
-  describe ".singleton_instance" do
-    it "should raise an exception when called on a non-singleton-class" do
-      lambda{ Pry::WrappedModule.new(Class).singleton_instance }.should.raise ArgumentError
-    end
-
-    it "should return the attached object" do
-      Pry::WrappedModule.new(class << "hi"; self; end).singleton_instance.should == "hi"
-      Pry::WrappedModule.new(class << Object; self; end).singleton_instance.should.equal?(Object)
-    end
-  end
-end
-

data/test/testrc

@@ -1,2 +0,0 @@
-TEST_RC = [] if !Object.const_defined?(:TEST_RC)
-TEST_RC << 0

data/test/testrcbad

@@ -1,2 +0,0 @@
-TEST_BEFORE_RAISE = 1
-raise "messin with ya"

data/wiki/Customizing-pry.md

@@ -1,397 +0,0 @@
-Customizing Pry
----------------
-
-Pry supports customization of the input, the output, the commands,
-the hooks, the prompt, and the 'print' object (the "P" in REPL).
-
-Global customization, which applies to all Pry sessions, is done
-through invoking class accessors on the `Pry` class, the accessors
-are:
-
-* `Pry.input=`
-* `Pry.output=`
-* `Pry.commands=`
-* `Pry.hooks=`
-* `Pry.prompt=`
-* `Pry.print=`
-
-Local customization (applied to a single Pry session) is done by
-passing config hash options to `Pry.start()` or to `Pry.new()`; also the
-same accessors as described above for the `Pry` class exist for a
-Pry instance so that customization can occur at runtime.
-
-### Input
-
-For input Pry accepts any object that implements the `readline` method. This
-includes `IO` objects, `StringIO`, `Readline`, `File` and custom objects. Pry
-initially defaults to using `Readline` for input.
-
-#### Example: Setting global input
-
-Setting Pry's global input causes all subsequent Pry instances to use
-this input by default:
-
-    Pry.input = StringIO.new("@x = 10\nexit")
-    Object.pry
-
-    Object.instance_variable_get(:@x) #=> 10
-
-The above will execute the code in the `StringIO`
-non-interactively. It gets all the input it needs from the `StringIO`
-and then exits the Pry session. Note it is important to end the
-session with 'exit' if you are running non-interactively or the Pry
-session will hang as it loops indefinitely awaiting new input.
-
-#### Example: Setting input for a specific session
-
-The settings for a specific session override the global settings
-(discussed above). There are two ways to set input for a specific pry session: At the
-point the session is started, or within the session itself (at runtime):
-
-##### At session start
-
-    Pry.start(Object, :input => StringIO.new("@x = 10\nexit"))
-    Object.instance_variable_get(:@x) #=> 10
-
-##### At runtime
-
-If you want to set the input object within the session itself you use
-the special `_pry_` local variable which represents the Pry instance
-managing the current session; inside the session we type:
-
-    _pry_.input = StringIO.new("@x = 10\nexit")
-
-Note we can also set the input object for the parent Pry session (if
-the current session is nested) like so:
-
-    _pry_.parent.input = StringIO.new("@x = 10\nexit")
-
-### Output
-
-For output Pry accepts any object that implements the `puts` method. This
-includes `IO` objects, `StringIO`, `File` and custom objects. Pry initially
-defaults to using `$stdout` for output.
-
-#### Example: Setting global output
-
-Setting Pry's global output causes all subsequent Pry instances to use
-this output by default:
-
-    Pry.output = StringIO.new
-
-#### Example: Setting output for a specific session
-
-As per Input, given above, we set the local output as follows:
-
-##### At session start
-
-    Pry.start(Object, :output => StringIO.new("@x = 10\nexit"))
-
-##### At runtime
-    
-    _pry_.output = StringIO.new
-
-### Commands
-
-Pry commands are not methods; they are commands that are intercepted
-and executed before a Ruby eval takes place. Pry comes with a default
-command set (`Pry::Commands`), but these commands can be augmented or overriden by
-user-specified ones.
-
-The Pry command API is quite sophisticated supporting features such as:
-command set inheritance, importing of specific commands from another
-command set, deletion of commands, calling of commands within other
-commands, and so on.
-
-A valid Pry command object must inherit from
-`Pry::CommandBase` (or one of its subclasses) and use the special command API:
-
-#### Example: Defining a command object and setting it globally
-
-    class MyCommands < Pry::CommandBase
-      command "greet", "Greet the user." do |name, age|
-        output.puts "Hello #{name.capitalize}, how does it feel being #{age}?"
-      end
-    end
-
-    Pry.commands = MyCommands
-
-Then inside a pry session:
-
-    pry(main)> greet john 9
-    Hello John, how does it feel being 9?
-    => nil
-
-#### Example: Using a command object in a specific session
-
-As in the case of `input` and `output`:
-
-##### At session start:
-
-    Pry.start(self, :commands => MyCommands)
-
-##### At runtime:
-
-    _pry_.commands = MyCommands
-
-#### The command API
-
-The command API is defined by the `Pry::CommandBase` class (hence why
-all commands must inherit from it or a subclass). The API works as follows:
-
-##### `command` method
-
-The `command` method defines a new command, its parameter is the
-name of the command and an optional second parameter is a description of
-the command.
-
-The associated block defines the action to be performed. The number of
-parameters in the block determine the number of parameters that will
-be sent to the command (from the Pry prompt) when it is invoked. Note
-that all parameters that are received will be strings; if a parameter
-is not received it will be set to `nil`.
-
-    command "hello" do |x, y, z|
-      puts "hello there #{x}, #{y}, and #{z}!"
-    end
-
-Command aliases can also be defined - simply use an array of strings
-for the command name - all these strings will be valid names for the
-command.
-
-    command ["ls", "dir"], "show a list of local vars" do
-      output.puts target.eval("local_variables")
-    end
-
-##### `delete` method
-
-The `delete` method deletes a command or a group of commands. It
-can be useful when inheriting from another command set and you wish
-to keep only a portion of the inherited commands.
-
-    class MyCommands < Pry::Commands
-      delete "show_method", "show_imethod"
-    end
-
-##### `import_from` method
-
-The `import_from` method enables you to specifically select which
-commands will be copied across from another command set, useful when
-you only want a small number of commands and so inheriting and then
-deleting would be inefficient. The first parameter to `import_from`
-is the class to import from and the other paramters are the names of
-the commands to import:
-
-    class MyCommands < Pry::CommandBase
-      import_from Pry::Commands, "ls", "status", "!"
-    end
-
-##### `run` method
-
-The `run` command invokes one command from within another.
-The first parameter is the name of the command to invoke
-and the remainder of the parameters will be passed on to the command
-being invoked:
-
-    class MyCommands < Pry::Commands
-      command "ls_with_hello" do
-        output.puts "hello!"
-        run "ls"
-      end
-    end
-
-##### `alias_command` method
-
-The `alias_command` method creates an alias of a command. The first
-parameter is the name of the new command, the second parameter is the
-name of the command to be aliased; an optional third parameter is the
-description to use for the alias. If no description is provided then
-the description of the original command is used.
-
-    class MyCommands < Pry::Commands
-      alias_command "help2", "help", "An alias of help"
-    end
-
-##### `desc` method
-
-The `desc` method is used to give a command a new description. The
-first parameter is the name of the command, the second parameter is
-the description.
-
-    class MyCommands < Pry::Commands
-      desc "ls", "a new description"
-    end
-
-#### Utility methods for commands
-
-All commands can access the special `output` and `target` methods. The
-`output` method returns the `output` object for the active pry session.
-Ensuring that your commands invoke `puts` on this rather than using
-the top-level `puts` will ensure that all your session output goes to
-the same place.
-
-The `target` method returns the `Binding` object the Pry session is currently
-active on - useful when your commands need to manipulate or examine
-the state of the object. E.g, the "ls" command is implemented as follows
-
-    command "ls" do
-      output.puts target.eval("local_variables + instance_variables").inspect
-    end
-
-#### The opts hash
-
-These are miscellaneous variables that may be useful to your commands:
-
-* `opts[:val]` - The line of input that invoked the command.
-* `opts[:eval_string]` - The cumulative lines of input for multi-line input.
-* `opts[:nesting]` - Lowlevel session nesting information.
-* `opts[:commands]` - Lowlevel data of all Pry commands.
-
-(see commands.rb for examples of how some of these options are used)
-
-#### The `help` command
-
-The `Pry::CommandBase` class automatically defines a `help` command
-for you. Typing `help` in a Pry session will show a list of commands
-to the user followed by their descriptions. Passing a parameter to
-`help` with the command name will just return the description of that
-specific command. If a description is left out it will automatically
-be given the description "No description.".
-
-If the description is explicitly set to `""` then this command will
-not be displayed in `help`.
-
-### Hooks
-
-Currently Pry supports just two hooks: `before_session` and
-`after_session`. These hooks are invoked before a Pry session starts
-and after a session ends respectively. The default hooks used are
-stored in the `Pry::DEFAULT_HOOKS` and just output the text `"Beginning
-Pry session for <obj>"` and `"Ending Pry session for <obj>"`.
-
-#### Example: Setting global hooks
-
-All subsequent Pry instances will use these hooks as default:
-
-    Pry.hooks = {
-      :before_session => proc { |out, obj| out.puts "Opened #{obj}" },
-      :after_session => proc { |out, obj| out.puts "Closed #{obj}" }
-    }
-
-    5.pry
-
-Inside the session:
-
-    Opened 5
-    pry(5)> exit
-    Closed 5
-
-Note that the `before_session` and `after_session` procs receive the
-current session's output object and session receiver as parameters.
-
-#### Example: Setting hooks for a specific session
-
-Like all the other customization options, the global default (as
-explained above) can be overriden for a specific session, either at
-session start or during runtime.
-
-##### At session start
-
-    Pry.start(self, :hooks => { :before_session => proc { puts "hello world!" },
-                                :after_session => proc { puts "goodbye world!" }
-                              })
-
-##### At runtime
-
-    _pry_.hooks = { :before_session => proc { puts "puts "hello world!" } }
-
-### Prompts
-
-The Pry prompt is used by `Readline` and other input objects that
-accept a prompt. Pry can accept two prompt-types for every prompt; the
-'main prompt' and the 'wait prompt'. The main prompt is always used
-for the first line of input; the wait prompt is used in multi-line
-input to indicate that the current expression is incomplete and more lines of
-input are required. The default Prompt used by Pry is stored in the
-`Pry::DEFAULT_PROMPT` constant.
-
-A valid Pry prompt is either a single `Proc` object or a two element
-array of `Proc` objects. When an array is used the first element is
-the 'main prompt' and the last element is the 'wait prompt'. When a
-single `Proc` object is used it will be used for both the main prompt
-and the wait prompt.
-
-#### Example: Setting global prompt
-
-The prompt `Proc` objects are passed the receiver of the Pry session
-and the nesting level of that session as parameters (they can simply
-ignore these if they do not need them).
-
-    # Using one proc for both main and wait prompts
-    Pry.prompt = proc { |obj, nest_level| "#{obj}:#{nest_level}> " }
-
-    # Alternatively, provide two procs; one for main and one for wait
-    Pry.prompt = [ proc { "ENTER INPUT> " }, proc { "MORE INPUT REQUIRED!* " }]
-
-#### Example: Setting the prompt for a specific session
-
-##### At session start
-
-    Pry.start(self, :prompt => [proc { "ENTER INPUT> " },
-                                proc { "MORE INPUT REQUIRED!* " }])
-
-##### At runtime
-
-    _pry_.prompt = [proc { "ENTER INPUT> " },
-                    proc { "MORE INPUT REQUIRED!* " }]
-
-### Print
-
-The Print phase of Pry's READ-EVAL-PRINT-LOOP can be customized. The
-default action is stored in the `Pry::DEFAULT_PRINT` constant and it
-simply outputs the value of the current expression preceded by a `=>` (or the first
-line of the backtrace if the value is an `Exception` object.)
-
-The print object should be a `Proc` and the parameters passed to the
-`Proc` are the output object for the current session and the 'value'
-returned by the current expression.
-
-#### Example: Setting global print object
-
-Let's define a print object that displays the full backtrace of any
-exception and precedes the output of a value by the text `"Output is: "`:
-
-    Pry.print = proc do |output, value|
-                  case value
-                  when Exception
-                    output.puts value.backtrace
-                  else
-                    output.puts "Output is: #{value}"
-                  end
-                end
-
-#### Example: Setting the print object for a specific session
-
-##### At session start
-
-    Pry.start(self, :print => proc do |output, value|
-                                case value
-                                when Exception
-                                  output.puts value.backtrace
-                                else
-                                  output.puts "Output is: #{value.inspect}"
-                                end
-                              end)
-
-##### At runtime
-
-    _pry_.print =  proc do |output, value|
-                     case value
-                     when Exception
-                       output.puts value.backtrace
-                     else
-                       output.puts "Output is: #{value.inspect}"
-                     end
-                   end
-    
-[Back to front page of documentation](http://rdoc.info/github/banister/pry/master/file/README.markdown)