1
0
Fork 0
mirror of https://github.com/pry/pry.git synced 2022-11-09 12:35:05 -05:00
pry--pry/README.md

408 lines
15 KiB
Markdown
Raw Normal View History

[![Build Status](https://img.shields.io/travis/pry/pry.svg)](https://travis-ci.org/pry/pry)
[![Code Climate](https://img.shields.io/codeclimate/github/pry/pry.svg)](https://codeclimate.com/github/pry/pry)
2015-01-13 12:22:30 -05:00
[![Inline docs](http://inch-ci.org/github/pry/pry.svg?style=shields)](http://inch-ci.org/github/pry/pry)
<br><br>
![logo for Pry](https://dl.dropbox.com/u/26521875/pry%20stuff/logo/pry_logo_350.png)
2010-12-08 02:30:38 -05:00
2016-01-02 13:56:59 -05:00
© John Mair ([banisterfiend](https://twitter.com/banisterfiend)) 2016<br>
2010-12-08 02:30:38 -05:00
2015-11-05 00:37:09 -05:00
**Please** [DONATE](http://pledgie.com/campaigns/15899) to the Pry project - Pry was a **huge** amount of work and every donation received is encouraging and supports Pry's continued development!
**Sponsors**
2015-12-05 00:18:12 -05:00
[Launch School](https://launchschool.com)<br/>
2015-11-05 00:37:09 -05:00
[Atomic Object](https://atomicobject.com/)<br/>
2016-08-18 14:01:12 -04:00
[Hashrocket](https://hashrocket.com/)<br/>
2015-11-05 00:37:09 -05:00
[Intridea](http://www.intridea.com)<br/>
2016-11-03 17:12:21 -04:00
[Gaslight](https://teamgaslight.com)<br/>
**Other Resources**
2011-07-12 07:24:39 -04:00
2015-11-05 00:37:09 -05:00
[Skip to the website (recommended)](http://pryrepl.org/) <br />
2011-07-12 07:28:21 -04:00
[Skip to the wiki](https://github.com/pry/pry/wiki)
added highlighting to disabled commands in GNU bash, version 4.1.5(1)-release (i486-pc-linux-gnu) These shell commands are defined internally. Type `help' to see this list. Type `help name' to find out more about the function `name'. Use `info bash' to find out more about the shell in general. Use `man -k' or `info' to find out more about commands not in this list. A star (*) next to a name means that the command is disabled. job_spec [&] history [-c] [-d offset] [n] or history -anrw [filename] o> (( expression )) if COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS> . filename [arguments] jobs [-lnprs] [jobspec ...] or jobs -x command [args] : kill [-s sigspec | -n signum | -sigspec] pid | jobspec ...> [ arg... ] let arg [arg ...] [[ expression ]] local [option] name[=value] ... alias [-p] [name[=value] ... ] logout [n] bg [job_spec ...] mapfile [-n count] [-O origin] [-s count] [-t] [-u fd] [-C> bind [-lpvsPVS] [-m keymap] [-f filename] [-q name] [-u nam> popd [-n] [+N | -N] break [n] printf [-v var] format [arguments] builtin [shell-builtin [arg ...]] pushd [-n] [+N | -N | dir] caller [expr] pwd [-LP] case WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esac read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-> cd [-L|-P] [dir] readarray [-n count] [-O origin] [-s count] [-t] [-u fd] [> command [-pVv] command [arg ...] readonly [-af] [name[=value] ...] or readonly -p compgen [-abcdefgjksuv] [-o option] [-A action] [-G globpa> return [n] complete [-abcdefgjksuv] [-pr] [-DE] [-o option] [-A action> select NAME [in WORDS ... ;] do COMMANDS; done compopt [-o|+o option] [-DE] [name ...] set [--abefhkmnptuvxBCHP] [-o option-name] [arg ...] continue [n] shift [n] coproc [NAME] command [redirections] shopt [-pqsu] [-o] [optname ...] declare [-aAfFilrtux] [-p] [name[=value] ...] source filename [arguments] dirs [-clpv] [+N] [-N] suspend [-f] disown [-h] [-ar] [jobspec ...] test [expr] echo [-neE] [arg ...] time [-p] pipeline enable [-a] [-dnps] [-f filename] [name ...] times eval [arg ...] trap [-lp] [[arg] signal_spec ...] exec [-cl] [-a name] [command [arguments ...]] [redirection> true exit [n] type [-afptP] name [name ...] export [-fn] [name[=value] ...] or export -p typeset [-aAfFilrtux] [-p] name[=value] ... false ulimit [-SHacdefilmnpqrstuvx] [limit] fc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [com> umask [-p] [-S] [mode] fg [job_spec] unalias [-a] name [name ...] for NAME [in WORDS ... ] ; do COMMANDS; done unset [-f] [-v] [name ...] for (( exp1; exp2; exp3 )); do COMMANDS; done until COMMANDS; do COMMANDS; done function name { COMMANDS ; } or name () { COMMANDS ; } variables - Names and meanings of some shell variables getopts optstring name [arg] wait [id] hash [-lr] [-p pathname] [-dt] [name ...] while COMMANDS; do COMMANDS; done help [-dms] [pattern ...] { COMMANDS ; }
2011-04-13 07:49:45 -04:00
Pry is a powerful alternative to the standard IRB shell for Ruby. It is
2012-06-17 00:19:19 -04:00
written from scratch to provide a number of advanced features,
including:
added highlighting to disabled commands in GNU bash, version 4.1.5(1)-release (i486-pc-linux-gnu) These shell commands are defined internally. Type `help' to see this list. Type `help name' to find out more about the function `name'. Use `info bash' to find out more about the shell in general. Use `man -k' or `info' to find out more about commands not in this list. A star (*) next to a name means that the command is disabled. job_spec [&] history [-c] [-d offset] [n] or history -anrw [filename] o> (( expression )) if COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS> . filename [arguments] jobs [-lnprs] [jobspec ...] or jobs -x command [args] : kill [-s sigspec | -n signum | -sigspec] pid | jobspec ...> [ arg... ] let arg [arg ...] [[ expression ]] local [option] name[=value] ... alias [-p] [name[=value] ... ] logout [n] bg [job_spec ...] mapfile [-n count] [-O origin] [-s count] [-t] [-u fd] [-C> bind [-lpvsPVS] [-m keymap] [-f filename] [-q name] [-u nam> popd [-n] [+N | -N] break [n] printf [-v var] format [arguments] builtin [shell-builtin [arg ...]] pushd [-n] [+N | -N | dir] caller [expr] pwd [-LP] case WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esac read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-> cd [-L|-P] [dir] readarray [-n count] [-O origin] [-s count] [-t] [-u fd] [> command [-pVv] command [arg ...] readonly [-af] [name[=value] ...] or readonly -p compgen [-abcdefgjksuv] [-o option] [-A action] [-G globpa> return [n] complete [-abcdefgjksuv] [-pr] [-DE] [-o option] [-A action> select NAME [in WORDS ... ;] do COMMANDS; done compopt [-o|+o option] [-DE] [name ...] set [--abefhkmnptuvxBCHP] [-o option-name] [arg ...] continue [n] shift [n] coproc [NAME] command [redirections] shopt [-pqsu] [-o] [optname ...] declare [-aAfFilrtux] [-p] [name[=value] ...] source filename [arguments] dirs [-clpv] [+N] [-N] suspend [-f] disown [-h] [-ar] [jobspec ...] test [expr] echo [-neE] [arg ...] time [-p] pipeline enable [-a] [-dnps] [-f filename] [name ...] times eval [arg ...] trap [-lp] [[arg] signal_spec ...] exec [-cl] [-a name] [command [arguments ...]] [redirection> true exit [n] type [-afptP] name [name ...] export [-fn] [name[=value] ...] or export -p typeset [-aAfFilrtux] [-p] name[=value] ... false ulimit [-SHacdefilmnpqrstuvx] [limit] fc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [com> umask [-p] [-S] [mode] fg [job_spec] unalias [-a] name [name ...] for NAME [in WORDS ... ] ; do COMMANDS; done unset [-f] [-v] [name ...] for (( exp1; exp2; exp3 )); do COMMANDS; done until COMMANDS; do COMMANDS; done function name { COMMANDS ; } or name () { COMMANDS ; } variables - Names and meanings of some shell variables getopts optstring name [arg] wait [id] hash [-lr] [-p pathname] [-dt] [name ...] while COMMANDS; do COMMANDS; done help [-dms] [pattern ...] { COMMANDS ; }
2011-04-13 07:49:45 -04:00
2011-04-23 08:22:51 -04:00
* Source code browsing (including core C source with the pry-doc gem)
* Documentation browsing
* Live help system
* Open methods in editors (`edit Class#method`)
2011-04-18 01:56:17 -04:00
* Syntax highlighting
2011-04-23 08:22:51 -04:00
* Command shell integration (start editors, run git, and rake from within Pry)
* Gist integration
* Navigation around state (`cd`, `ls` and friends)
* Runtime invocation (use Pry as a developer console or debugger)
2012-03-11 07:28:16 -04:00
* Exotic object support (BasicObject instances, IClasses, ...)
2012-03-11 07:31:45 -04:00
* A Powerful and flexible command system
* Ability to view and replay history
2011-09-08 12:35:45 -04:00
* Many convenience commands inspired by IPython, Smalltalk and other advanced REPLs
2012-02-29 20:36:21 -05:00
* A wide-range number of [plugins](https://github.com/pry/pry/wiki/Available-plugins) that provide remote sessions, full debugging functionality, and more.
2010-12-08 02:30:38 -05:00
Pry also aims to be more than an IRB replacement; it is an
attempt to bring REPL driven programming to the Ruby language. It is
2015-11-05 00:37:09 -05:00
currently not as powerful as tools like [SLIME](https://en.wikipedia.org/wiki/SLIME) for lisp, but that is the
general direction Pry is heading.
Pry is also fairly flexible and allows significant user
2011-07-12 07:07:10 -04:00
[customization](https://github.com/pry/pry/wiki/Customization-and-configuration)
2011-01-30 08:50:18 -05:00
is trivial to set it to read from any object that has a `readline` method and write to any object that has a
2011-01-29 21:00:19 -05:00
`puts` method - many other aspects of Pry are also configurable making
it a good choice for implementing custom shells.
Pry comes with an executable so it can be invoked at the command line.
Just enter `pry` to start. A `.pryrc` file in the user's home directory will
be loaded if it exists. Type `pry --help` at the command line for more
information.
Try `gem install pry-doc` for additional documentation on Ruby Core
methods. The additional docs are accessed through the `show-doc` and
`show-method` commands.
2010-12-08 06:39:06 -05:00
* Install the [gem](https://rubygems.org/gems/pry): `gem install pry`
2011-07-12 07:24:39 -04:00
* Browse the comprehensive [documentation at the official Pry wiki](https://github.com/pry/pry/wiki)
2016-01-08 12:03:46 -05:00
* Read the [YARD API documentation](http://www.rubydoc.info/github/pry/pry/)
2015-11-05 00:37:09 -05:00
* See the [source code](https://github.com/pry/pry)
2010-12-08 02:30:38 -05:00
2011-04-23 06:43:56 -04:00
### Commands
2011-04-23 08:22:51 -04:00
Nearly every piece of functionality in a Pry session is implemented as
a command. Commands are not methods and must start at the beginning of a line, with no
2011-04-23 06:43:56 -04:00
whitespace in between. Commands support a flexible syntax and allow
2011-04-23 08:22:51 -04:00
'options' in the same way as shell commands, for example the following
Pry command will show a list of all private instance methods (in
scope) that begin with 'pa'
2011-07-12 08:58:57 -04:00
pry(YARD::Parser::SourceParser):5> ls -Mp --grep ^pa
2012-02-29 20:36:21 -05:00
YARD::Parser::SourceParser#methods: parse parser_class parser_type parser_type= parser_type_for_filename
2011-04-23 08:22:51 -04:00
2011-04-20 22:43:52 -04:00
### Navigating around state
2010-12-08 02:30:38 -05:00
2011-04-18 01:56:17 -04:00
Pry allows us to pop in and out of different scopes (objects) using
2011-04-22 08:47:15 -04:00
the `cd` command. This enables us to explore the run-time view of a
program or library. To view which variables and methods are available
2011-04-20 22:43:52 -04:00
within a particular scope we use the versatile [ls command.](https://gist.github.com/c0fc686ef923c8b87715)
2010-12-08 06:39:06 -05:00
2011-04-23 08:22:51 -04:00
Here we will begin Pry at top-level, then Pry on a class and then on
2010-12-08 06:39:06 -05:00
an instance variable inside that class:
pry(main)> class Hello
pry(main)* @x = 20
pry(main)* end
=> 20
2011-02-17 05:01:33 -05:00
pry(main)> cd Hello
2011-04-18 01:56:17 -04:00
pry(Hello):1> ls -i
2012-02-29 20:36:21 -05:00
instance variables: @x
2011-02-17 05:01:33 -05:00
pry(Hello):1> cd @x
2014-01-15 09:09:08 -05:00
pry(20):2> self + 10
2010-12-08 06:39:06 -05:00
=> 30
2014-01-15 09:09:08 -05:00
pry(20):2> cd ..
2011-02-19 05:28:41 -05:00
pry(Hello):1> cd ..
pry(main)> cd ..
The number after the `:` in the pry prompt indicates the nesting
level. To display more information about nesting, use the `nesting`
command. E.g
2014-01-15 09:09:08 -05:00
pry("friend"):3> nesting
Nesting status:
0. main (Pry top level)
1. Hello
2. 100
3. "friend"
=> nil
We can then jump back to any of the previous nesting levels by using
the `jump-to` command:
2014-01-15 09:09:08 -05:00
pry("friend"):3> jump-to 1
=> 100
pry(Hello):1>
2011-04-20 22:43:52 -04:00
### Runtime invocation
Pry can be invoked in the middle of a running program. It opens a Pry
session at the point it's called and makes all program state at that
point available. It can be invoked on any object using the
`my_object.pry` syntax or on the current binding (or any binding)
using `binding.pry`. The Pry session will then begin within the scope
of the object (or binding). When the session ends the program continues with any
modifications you made to it.
This functionality can be used for such things as: debugging,
implementing developer consoles and applying hot patches.
code:
2015-10-13 22:26:37 -04:00
```ruby
# test.rb
require 'pry'
2015-10-13 22:26:37 -04:00
class A
def hello() puts "hello world!" end
end
2015-10-13 22:26:37 -04:00
a = A.new
2015-10-13 22:26:37 -04:00
# start a REPL session
binding.pry
2015-10-13 22:26:37 -04:00
# program resumes here (after pry session)
puts "program resumes here."
```
Pry session:
pry(main)> a.hello
hello world!
=> nil
pry(main)> def a.goodbye
pry(main)* puts "goodbye cruel world!"
pry(main)* end
=> nil
pry(main)> a.goodbye
goodbye cruel world!
=> nil
pry(main)> exit
2011-04-18 04:08:14 -04:00
program resumes here.
2011-04-20 22:43:52 -04:00
### Command Shell Integration
A line of input that begins with a '.' will be forwarded to the
command shell. This enables us to navigate the file system, spawn
2011-04-20 22:43:52 -04:00
editors, and run git and rake directly from within Pry.
Further, we can use the `shell-mode` command to incorporate the
2011-04-20 22:43:52 -04:00
present working directory into the Pry prompt and bring in (limited at this stage, sorry) file name completion.
We can also interpolate Ruby code directly into the shell by
using the normal `#{}` string interpolation syntax.
2011-04-20 22:43:52 -04:00
In the code below we're going to switch to `shell-mode` and edit the
`.pryrc` file in the home directory. We'll then cat its contents and
2011-04-20 22:43:52 -04:00
reload the file.
pry(main)> shell-mode
2011-04-20 22:43:52 -04:00
pry main:/home/john/ruby/projects/pry $ .cd ~
pry main:/home/john $ .emacsclient .pryrc
pry main:/home/john $ .cat .pryrc
def hello_world
puts "hello world!"
end
pry main:/home/john $ load ".pryrc"
=> true
pry main:/home/john $ hello_world
2011-04-20 22:43:52 -04:00
hello world!
We can also interpolate Ruby code into the shell. In the
example below we use the shell command `cat` on a random file from the
current directory and count the number of lines in that file with
`wc`:
2011-04-20 22:43:52 -04:00
pry main:/home/john $ .cat #{Dir['*.*'].sample} | wc -l
44
2011-04-20 22:43:52 -04:00
### Code Browsing
You can browse method source code with the `show-method` command. Nearly all Ruby methods (and some C methods, with the pry-doc
gem) can have their source viewed. Code that is longer than a page is
sent through a pager (such as less), and all code is properly syntax
highlighted (even C code).
2011-04-20 22:43:52 -04:00
The `show-method` command accepts two syntaxes, the typical ri
`Class#method` syntax and also simply the name of a method that's in
scope. You can optionally pass the `-l` option to show-method to
include line numbers in the output.
2011-04-20 22:43:52 -04:00
In the following example we will enter the `Pry` class, list the
instance methods beginning with 're' and display the source code for the `rep` method:
2011-04-20 22:43:52 -04:00
pry(main)> cd Pry
2014-01-15 09:09:08 -05:00
pry(Pry):1> ls -M --grep re
2012-02-29 19:04:57 -05:00
Pry#methods: re readline refresh rep repl repl_epilogue repl_prologue retrieve_line
2011-04-20 22:43:52 -04:00
pry(Pry):1> show-method rep -l
2011-04-20 22:43:52 -04:00
From: /home/john/ruby/projects/pry/lib/pry/pry_instance.rb @ line 143:
Number of lines: 6
2011-04-20 22:43:52 -04:00
143: def rep(target=TOPLEVEL_BINDING)
144: target = Pry.binding_for(target)
145: result = re(target)
146:
2011-04-20 22:43:52 -04:00
147: show_result(result) if should_print?
148: end
Note that we can also view C methods (from Ruby Core) using the
2011-07-12 07:07:10 -04:00
`pry-doc` plugin; we also show off the alternate syntax for
2011-04-20 22:43:52 -04:00
`show-method`:
2011-04-20 22:43:52 -04:00
pry(main)> show-method Array#select
2011-04-20 22:43:52 -04:00
From: array.c in Ruby Core (C Method):
Number of lines: 15
2011-04-20 22:43:52 -04:00
static VALUE
rb_ary_select(VALUE ary)
{
VALUE result;
long i;
2011-04-20 22:43:52 -04:00
RETURN_ENUMERATOR(ary, 0, 0);
result = rb_ary_new2(RARRAY_LEN(ary));
for (i = 0; i < RARRAY_LEN(ary); i++) {
2014-01-15 09:09:08 -05:00
if (RTEST(rb_yield(RARRAY_PTR(ary)[i]))) {
rb_ary_push(result, rb_ary_elt(ary, i));
}
2011-04-20 22:43:52 -04:00
}
return result;
}
2011-04-23 06:43:56 -04:00
### Documentation Browsing
2011-04-22 08:47:15 -04:00
One use-case for Pry is to explore a program at run-time by `cd`-ing
in and out of objects and viewing and invoking methods. In the course
of exploring it may be useful to read the documentation for a
specific method that you come across. Like `show-method` the `show-doc` command supports
two syntaxes - the normal `ri` syntax as well as accepting the name of
any method that is currently in scope.
The Pry documentation system does not rely on pre-generated `rdoc` or
`ri`, instead it grabs the comments directly above the method on
demand. This results in speedier documentation retrieval and allows
the Pry system to retrieve documentation for methods that would not be
picked up by `rdoc`. Pry also has a basic understanding of both the
rdoc and yard formats and will attempt to syntax highlight the
documentation appropriately.
2012-07-09 15:54:17 -04:00
Nonetheless, the `ri` functionality is very good and
2011-04-22 08:47:15 -04:00
has an advantage over Pry's system in that it allows documentation
lookup for classes as well as methods. Pry therefore has good
integration with `ri` through the `ri` command. The syntax
for the command is exactly as it would be in command-line -
2011-04-23 06:43:56 -04:00
so it is not necessary to quote strings.
2011-04-22 08:47:15 -04:00
In our example we will enter the `Gem` class and view the
documentation for the `try_activate` method:
pry(main)> cd Gem
2011-04-23 06:43:56 -04:00
pry(Gem):1> show-doc try_activate
2011-04-22 08:47:15 -04:00
From: /Users/john/.rvm/rubies/ruby-1.9.2-p180/lib/ruby/site_ruby/1.9.1/rubygems.rb @ line 201:
Number of lines: 3
2011-04-22 08:47:15 -04:00
Try to activate a gem containing path. Returns true if
activation succeeded or wasn't needed because it was already
activated. Returns false if it can't find the path in a gem.
pry(Gem):1>
We can also use `ri` in the normal way:
pry(main) ri Array#each
----------------------------------------------------------- Array#each
array.each {|item| block } -> array
------------------------------------------------------------------------
Calls _block_ once for each element in _self_, passing that element
as a parameter.
2011-04-22 08:47:15 -04:00
a = [ "a", "b", "c" ]
a.each {|x| print x, " -- " }
2011-04-22 08:47:15 -04:00
produces:
2011-04-22 08:47:15 -04:00
a -- b -- c --
2011-04-23 08:22:51 -04:00
### Gist integration
2015-05-21 11:22:28 -04:00
If the `gist` gem is installed then method source or documentation can be gisted to GitHub with the
2012-02-29 20:36:21 -05:00
`gist` command. The `gist` command is capable of gisting [almost any REPL content](https://gist.github.com/cae143e4533416529726), including methods, documentation,
2012-02-29 19:04:57 -05:00
input expressions, command source, and so on. In the example below we will gist the C source
2015-05-21 11:22:28 -04:00
code for the `Symbol#to_proc` method to GitHub:
2012-02-29 19:04:57 -05:00
pry(main)> gist -m Symbol#to_proc
Gist created at https://gist.github.com/5332c38afc46d902ce46 and added to clipboard.
pry(main)>
You can see the actual gist generated here: [https://gist.github.com/5332c38afc46d902ce46](https://gist.github.com/5332c38afc46d902ce46)
### Edit methods
You can use `edit Class#method` or `edit my_method`
(if the method is in scope) to open a method for editing directly in
your favorite editor. Pry has knowledge of a few different editors and
will attempt to open the file at the line the method is defined.
2011-04-25 13:11:07 -04:00
You can set the editor to use by assigning to the `Pry.editor`
accessor. `Pry.editor` will default to `$EDITOR` or failing that will
use `nano` as the backup default. The file that is edited will be
automatically reloaded after exiting the editor - reloading can be
suppressed by passing the `--no-reload` option to `edit`
In the example below we will set our default editor to "emacsclient"
and open the `Pry#repl` method for editing:
pry(main)> Pry.editor = "emacsclient"
pry(main)> edit Pry#repl
2011-04-23 08:22:51 -04:00
### Live Help System
2011-04-23 06:43:56 -04:00
2011-04-23 08:22:51 -04:00
Many other commands are available in Pry; to see the full list type
`help` at the prompt. A short description of each command is provided
with basic instructions for use; some commands have a more extensive
help that can be accessed via typing `command_name --help`. A command
2011-04-23 08:22:51 -04:00
will typically say in its description if the `--help` option is
2015-12-19 00:06:51 -05:00
available.
2010-12-08 06:39:06 -05:00
### Use Pry as your Rails Console
2013-07-22 21:27:46 -04:00
The recommended way to use Pry as your Rails console is to add
[the `pry-rails` gem](https://github.com/rweng/pry-rails) to
your Gemfile. This replaces the default console with Pry, in
addition to loading the Rails console helpers and adding some
useful Rails-specific commands.
2013-07-22 21:26:22 -04:00
If you don't want to change your Gemfile, you can still run a Pry
console in your app's environment using Pry's `-r` flag:
2013-07-22 21:26:22 -04:00
pry -r ./config/environment
2010-12-08 06:39:06 -05:00
2013-07-22 21:26:22 -04:00
Also check out the [wiki](https://github.com/pry/pry/wiki/Setting-up-Rails-or-Heroku-to-use-Pry)
for more information about integrating Pry with Rails.
2012-02-29 20:36:21 -05:00
2011-07-12 07:07:10 -04:00
### Limitations:
2011-04-23 10:03:56 -04:00
* Tab completion is currently a bit broken/limited this will have a
2011-07-12 07:07:10 -04:00
major overhaul in a future version.
### Syntax Highlighting
2013-07-17 07:48:22 -04:00
Syntax highlighting is on by default in Pry. If you want to change
the colors, check out the [pry-theme](https://github.com/kyrylo/pry-theme)
gem.
You can toggle the syntax highlighting on and off in a session by
using the `toggle-color` command. Alternatively, you can turn it off
permanently by putting the line `Pry.color = false` in your `~/.pryrc`
file.
### Future Directions
Many new features are planned such as:
2011-07-12 07:24:39 -04:00
* Increase modularity (rely more on plugin system)
* Much improved documentation system, better support for YARD
2011-07-12 07:24:39 -04:00
* Better support for code and method reloading and saving code
* Extended and more sophisticated command system, allowing piping
between commands and running commands in background
### Contact
2010-12-08 02:30:38 -05:00
2015-05-21 11:22:28 -04:00
Problems or questions? File an issue at [GitHub](https://github.com/pry/pry/issues).
2011-04-23 10:03:56 -04:00
### Contributors
2011-04-23 10:03:56 -04:00
2015-11-05 00:37:09 -05:00
Pry is primarily the work of [John Mair (banisterfiend)](https://github.com/banister), for full list
2011-09-08 12:35:45 -04:00
of contributors see the
[CONTRIBUTORS](https://github.com/pry/pry/blob/master/CONTRIBUTORS) file.