diff --git a/.document b/.document index d97eb7d73..9102e0963 100644 --- a/.document +++ b/.document @@ -1,4 +1,4 @@ LICENSE.txt README.md -doc +doc/irb/indexes.rdoc lib/**/*.rb diff --git a/.gitignore b/.gitignore index 4ea57987f..ff2a440ae 100644 --- a/.gitignore +++ b/.gitignore @@ -2,7 +2,6 @@ /.yardoc /_yardoc/ /coverage/ -/doc/ /pkg/ /spec/reports/ /tmp/ diff --git a/doc/irb/indexes.rdoc b/doc/irb/indexes.rdoc new file mode 100644 index 000000000..a0a95b4ba --- /dev/null +++ b/doc/irb/indexes.rdoc @@ -0,0 +1,190 @@ +== Indexes + +=== Index of Command-Line Options + +These are the \IRB command-line options, with links to explanatory text: + +- -d: Set $DEBUG and {$VERBOSE}[rdoc-ref:IRB@Verbosity] + to +true+. +- -E _ex_[:_in_]: Set initial external (ex) and internal (in) + {encodings}[rdoc-ref:IRB@Encodings] (same as ruby -E>). +- -f: Don't initialize from {configuration file}[rdoc-ref:IRB@Configuration+File]. +- -I _dirpath_: Specify {$LOAD_PATH directory}[rdoc-ref:IRB@Load+Modules] + (same as ruby -I). +- -r _load-module_: Require {load-module}[rdoc-ref:IRB@Load+Modules] + (same as ruby -r). +- -U: Set external and internal {encodings}[rdoc-ref:IRB@Encodings] to UTF-8. +- -w: Suppress {warnings}[rdoc-ref:IRB@Warnings] (same as ruby -w). +- -W[_level_]: Set {warning level}[rdoc-ref:IRB@Warnings]; + 0=silence, 1=medium, 2=verbose (same as ruby -W). +- --autocomplete: Use {auto-completion}[rdoc-ref:IRB@Automatic+Completion]. +- --back-trace-limit _n_: Set a {backtrace limit}[rdoc-ref:IRB@Tracer]; + display at most the top +n+ and bottom +n+ entries. +- --colorize: Use {color-highlighting}[rdoc-ref:IRB@Color+Highlighting] + for input and output. +- --context-mode _n_: Select method to create Binding object + for new {workspace}[rdoc-ref:IRB@Commands]; +n+ in range 0..4. +- --echo: Print ({echo}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + return values. +- --extra-doc-dir _dirpath_: + Add a {documentation directory}[rdoc-ref:IRB@RI+Documentation+Directories] + for the documentation dialog. +- --inf-ruby-mode: Set prompt mode to {:INF_RUBY}[rdoc-ref:IRB@Pre-Defined+Prompts] + (appropriate for +inf-ruby-mode+ on Emacs); + suppresses --multiline and --singleline. +- --inspect: Use method +inspect+ for printing ({echoing}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + return values. +- --multiline: Use the multiline editor as the {input method}[rdoc-ref:IRB@Input+Method]. +- --noautocomplete: Don't use {auto-completion}[rdoc-ref:IRB@Automatic+Completion]. +- --nocolorize: Don't use {color-highlighting}[rdoc-ref:IRB@Color+Highlighting] + for input and output. +- --noecho: Don't print ({echo}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + return values. +- --noecho-on-assignment: Don't print ({echo}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + result on assignment. +- --noinspect: Don't se method +inspect+ for printing ({echoing}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + return values. +- --nomultiline: Don't use the multiline editor as the {input method}[rdoc-ref:IRB@Input+Method]. +- --noprompt: Don't print {prompts}[rdoc-ref:IRB@Prompt+and+Return+Formats]. +- --noscript: Treat the first command-line argument as a normal + {command-line argument}[rdoc-ref:IRB@Initialization+Script], + and include it in +ARGV+. +- --nosingleline: Don't use the singleline editor as the {input method}[rdoc-ref:IRB@Input+Method]. +- --noverboseDon't print {verbose}[rdoc-ref:IRB@Verbosity] details. +- --prompt _mode_, --prompt-mode _mode_: + Set {prompt and return formats}[rdoc-ref:IRB@Prompt+and+Return+Formats]; + +mode+ may be a {pre-defined prompt}[rdoc-ref:IRB@Pre-Defined+Prompts] + or the name of a {custom prompt}[rdoc-ref:IRB@Custom+Prompts]. +- --script: Treat the first command-line argument as the path to an + {initialization script}[rdoc-ref:IRB@Initialization+Script], + and omit it from +ARGV+. +- --simple-prompt, --sample-book-mode: + Set prompt mode to {:SIMPLE}[rdoc-ref:IRB@Pre-Defined+Prompts]. +- --singleline: Use the singleline editor as the {input method}[rdoc-ref:IRB@Input+Method]. +- --tracer: Use {Tracer}[rdoc-ref:IRB@Tracer] to print a stack trace for each input command. +- --truncate-echo-on-assignment: Print ({echo}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + truncated result on assignment. +- --verbosePrint {verbose}[rdoc-ref:IRB@Verbosity] details. +- -v, --version: Print the {IRB version}[rdoc-ref:IRB@Version]. +- -h, --help: Print the {IRB help text}[rdoc-ref:IRB@Help]. +- --: Separate options from {arguments}[rdoc-ref:IRB@Command-Line+Arguments] + on the command-line. + +=== Index of \IRB.conf Entries + +These are the keys for hash \IRB.conf entries, with links to explanatory text; +for each entry that is pre-defined, the initial value is given: + +- :AP_NAME: \IRB {application name}[rdoc-ref:IRB@Application+Name]; + initial value: 'irb'. +- :AT_EXIT: Array of hooks to call + {at exit}[rdoc-ref:IRB@IRB]; + initial value: []. +- :AUTO_INDENT: Whether {automatic indentation}[rdoc-ref:IRB@Automatic+Indentation] + is enabled; initial value: +true+. +- :BACK_TRACE_LIMIT: Sets the {back trace limit}[rdoc-ref:IRB@Tracer]; + initial value: +16+. +- :COMMAND_ALIASES: Defines input {command aliases}[rdoc-ref:IRB@Command+Aliases]; + initial value: + + { + "$": :show_source, + "@": :whereami, + } + +- :CONTEXT_MODE: Sets the {context mode}[rdoc-ref:IRB@Context+Mode], + the type of binding to be used when evaluating statements; + initial value: +4+. +- :ECHO: Whether to print ({echo}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + return values; + initial value: +nil+, which would set +conf.echo+ to +true+. +- :ECHO_ON_ASSIGNMENT: Whether to print ({echo}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) + return values on assignment; + initial value: +nil+, which would set +conf.echo_on_assignment+ to +:truncate+. +- :EVAL_HISTORY: How much {evaluation history}[rdoc-ref:IRB@Evaluation+History] + is to be stored; initial value: +nil+. +- :EXTRA_DOC_DIRS: \Array of + {RI documentation directories}[rdoc-ref:IRB@RI+Documentation+Directories] + to be parsed for the documentation dialog; + initial value: []. +- :IGNORE_EOF: Whether to ignore {end-of-file}[rdoc-ref:IRB@End-of-File]; + initial value: +false+. +- :IGNORE_SIGINT: Whether to ignore {SIGINT}[rdoc-ref:IRB@SIGINT]; + initial value: +true+. +- :INSPECT_MODE: Whether to use method +inspect+ for printing + ({echoing}[rdoc-ref:IRB@Return-Value+Printing+-28Echoing-29]) return values; + initial value: +true+. +- :IRB_LIB_PATH: The path to the {IRB library directory}[rdoc-ref:IRB@IRB+Library+Directory]; initial value: + "RUBY_DIR/lib/ruby/gems/RUBY_VER_NUM/gems/irb-IRB_VER_NUM/lib/irb", + where: + + - RUBY_DIR is the Ruby installation dirpath. + - RUBY_VER_NUM is the Ruby version number. + - IRB_VER_NUM is the \IRB version number. + +- :IRB_NAME: {IRB name}[rdoc-ref:IRB@IRB+Name]; + initial value: 'irb'. +- :IRB_RC: {Configuration monitor}[rdoc-ref:IRB@Configuration+Monitor]; + initial value: +nil+. +- :LC_MESSAGES: {Locale}[rdoc-ref:IRB@Locale]; + initial value: IRB::Locale object. +- :LOAD_MODULES: deprecated. +- :MAIN_CONTEXT: The {context}[rdoc-ref:IRB@Session+Context] for the main \IRB session; + initial value: IRB::Context object. +- :MEASURE: Whether to + {measure performance}[rdoc-ref:IRB@Performance+Measurement]; + initial value: +false+. +- :MEASURE_CALLBACKS: Callback methods for + {performance measurement}[rdoc-ref:IRB@Performance+Measurement]; + initial value: []. +- :MEASURE_PROC: Procs for + {performance measurement}[rdoc-ref:IRB@Performance+Measurement]; + initial value: + + { + :TIME=>#, + :STACKPROF=># + } + +- :PROMPT: \Hash of {defined prompts}[rdoc-ref:IRB@Prompt+and+Return+Formats]; + initial value: + + { + :NULL=>{:PROMPT_I=>nil, :PROMPT_S=>nil, :PROMPT_C=>nil, :RETURN=>"%s\n"}, + :DEFAULT=>{:PROMPT_I=>"%N(%m):%03n> ", :PROMPT_S=>"%N(%m):%03n%l ", :PROMPT_C=>"%N(%m):%03n* ", :RETURN=>"=> %s\n"}, + :CLASSIC=>{:PROMPT_I=>"%N(%m):%03n:%i> ", :PROMPT_S=>"%N(%m):%03n:%i%l ", :PROMPT_C=>"%N(%m):%03n:%i* ", :RETURN=>"%s\n"}, + :SIMPLE=>{:PROMPT_I=>">> ", :PROMPT_S=>"%l> ", :PROMPT_C=>"?> ", :RETURN=>"=> %s\n"}, + :INF_RUBY=>{:PROMPT_I=>"%N(%m):%03n> ", :PROMPT_S=>nil, :PROMPT_C=>nil, :RETURN=>"%s\n", :AUTO_INDENT=>true}, + :XMP=>{:PROMPT_I=>nil, :PROMPT_S=>nil, :PROMPT_C=>nil, :RETURN=>" ==>%s\n"} + } + +- :PROMPT_MODE: Name of {current prompt}[rdoc-ref:IRB@Prompt+and+Return+Formats]; + initial value: +:DEFAULT+. +- :RC: Whether a {configuration file}[rdoc-ref:IRB@Configuration+File] + was found and interpreted; + initial value: +true+ if a configuration file was found, +false+ otherwise. +- :RC_NAME_GENERATOR: \Proc to generate paths of potential + {configuration files}[rdoc-ref:IRB@Configuration+File]; + initial value: => #. +- :SAVE_HISTORY: Number of commands to save in + {input command history}[rdoc-ref:IRB@Input+Command+History]; + initial value: +1000+. +- :SINGLE_IRB: Whether command-line option --single-irb was given; + initial value: +true+ if the option was given, +false+ otherwise. + See {Single-IRB Mode}[rdoc-ref:IRB@Single-IRB+Mode]. +- :USE_AUTOCOMPLETE: Whether to use + {automatic completion}[rdoc-ref:IRB@Automatic+Completion]; + initial value: +true+. +- :USE_COLORIZE: Whether to use + {color highlighting}[rdoc-ref:IRB@Color+Highlighting]; + initial value: +true+. +- :USE_LOADER: Whether to use the + {IRB loader}[rdoc-ref:IRB@IRB+Loader] for +require+ and +load+; + initial value: +false+. +- :USE_TRACER: Whether to use the + {IRB tracer}[rdoc-ref:IRB@Tracer]; + initial value: +false+. +- :VERBOSE: Whether to print {verbose output}[rdoc-ref:IRB@Verbosity]; + initial value: +nil+. +- :__MAIN__: The main \IRB object; + initial value: +main+. diff --git a/lib/irb.rb b/lib/irb.rb index 1ba335c08..aef1e69c6 100644 --- a/lib/irb.rb +++ b/lib/irb.rb @@ -22,36 +22,870 @@ require_relative "irb/debug" require_relative "irb/pager" -# IRB stands for "interactive Ruby" and is a tool to interactively execute Ruby -# expressions read from the standard input. +# == \IRB +# +# \Module \IRB ("Interactive Ruby") provides a shell-like interface +# that supports user interaction with the Ruby interpreter. # -# The +irb+ command from your shell will start the interpreter. +# It operates as a read-eval-print loop +# ({REPL}[https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop]) +# that: # -# == Usage +# - _Reads_ each character as you type. +# You can modify the \IRB context to change the way input works. +# See {Input}[rdoc-ref:IRB@Input]. +# - _Evaluates_ the code each time it has read a syntactically complete passage. +# - _Prints_ after evaluating. +# You can modify the \IRB context to change the way output works. +# See {Output}[rdoc-ref:IRB@Output]. # -# Use of irb is easy if you know Ruby. +# Example: # -# When executing irb, prompts are displayed as follows. Then, enter the Ruby -# expression. An input is executed when it is syntactically complete. +# $ irb +# irb(main):001> File.basename(Dir.pwd) +# => "irb" +# irb(main):002> Dir.entries('.').size +# => 25 +# irb(main):003* Dir.entries('.').select do |entry| +# irb(main):004* entry.start_with?('R') +# irb(main):005> end +# => ["README.md", "Rakefile"] # -# $ irb -# irb(main):001:0> 1+2 -# #=> 3 -# irb(main):002:0> class Foo -# irb(main):003:1> def foo -# irb(main):004:2> print 1 -# irb(main):005:2> end -# irb(main):006:1> end -# #=> nil +# The typed input may also include +# {\IRB-specific commands}[rdoc-ref:IRB@IRB-Specific+Commands]. # -# The singleline editor module or multiline editor module can be used with irb. -# Use of multiline editor is default if it's installed. +# As seen above, you can start \IRB by using the shell command +irb+. # -# == Command line options +# You can stop an \IRB session by typing command +exit+: # -# :include: ./irb/lc/help-message +# irb(main):006> exit +# $ # -# == Commands +# At that point, \IRB calls any hooks found in array IRB.conf[:AT_EXIT], +# then exits. +# +# == Startup +# +# At startup, \IRB: +# +# 1. Interprets (as Ruby code) the content of the +# {configuration file}[rdoc-ref:IRB@Configuration+File] (if given). +# 1. Constructs the initial session context +# from {hash IRB.conf}[rdoc-ref:IRB@Hash+IRB.conf] and from default values; +# the hash content may have been affected +# by {command-line options}[rdoc-ref:IB@Command-Line+Options], +# and by direct assignments in the configuration file. +# 1. Assigns the context to variable +conf+. +# 1. Assigns command-line arguments to variable ARGV. +# 1. Prints the {prompt}[rdoc-ref:IRB@Prompt+and+Return+Formats]. +# 1. Puts the content of the +# {initialization script}[rdoc-ref:IRB@Initialization+Script] +# onto the \IRB shell, just as if it were user-typed commands. +# +# === The Command Line +# +# On the command line, all options precede all arguments; +# the first item that is not recognized as an option is treated as an argument, +# as are all items that follow. +# +# ==== Command-Line Options +# +# Many command-line options affect entries in hash IRB.conf, +# which in turn affect the initial configuration of the \IRB session. +# +# Details of the options are described in the relevant subsections below. +# +# A cursory list of the \IRB command-line options +# may be seen in the {help message}[https://raw.githubusercontent.com/ruby/irb/master/lib/irb/lc/help-message], +# which is also displayed if you use command-line option --help. +# +# If you are interested in a specific option, consult the +# {index}[rdoc-ref:doc/irb/indexes.rdoc@Index+of+Command-Line+Options]. +# +# ==== Command-Line Arguments +# +# Command-line arguments are passed to \IRB in array +ARGV+: +# +# $ irb --noscript Foo Bar Baz +# irb(main):001> ARGV +# => ["Foo", "Bar", "Baz"] +# irb(main):002> exit +# $ +# +# Command-line option -- causes everything that follows +# to be treated as arguments, even those that look like options: +# +# $ irb --noscript -- --noscript -- Foo Bar Baz +# irb(main):001> ARGV +# => ["--noscript", "--", "Foo", "Bar", "Baz"] +# irb(main):002> exit +# $ +# +# === Configuration File +# +# You can initialize \IRB via a configuration file. +# +# If command-line option -f is given, +# no configuration file is looked for. +# +# Otherwise, \IRB reads and interprets a configuration file +# if one is available. +# +# The configuration file can contain any Ruby code, and can usefully include +# user code that: +# +# - Can then be debugged in \IRB. +# - Configures \IRB itself. +# - Requires or loads files. +# +# The path to the configuration file is the first found among: +# +# - The value of variable $IRBRC, if defined. +# - The value of variable $XDG_CONFIG_HOME/irb/irbrc, if defined. +# - File $HOME/.irbrc, if it exists. +# - File $HOME/.config/irb/irbrc, if it exists. +# - File +.config/irb/irbrc+ in the current directory, if it exists. +# - File +.irbrc+ in the current directory, if it exists. +# - File +irb.rc+ in the current directory, if it exists. +# - File +_irbrc+ in the current directory, if it exists. +# - File $irbrc in the current directory, if it exists. +# +# If the search fails, there is no configuration file. +# +# If the search succeeds, the configuration file is read as Ruby code, +# and so can contain any Ruby programming you like. +# +# \Method conf.rc? returns +true+ if a configuration file was read, +# +false+ otherwise. +# \Hash entry IRB.conf[:RC] also contains that value. +# +# === \Hash IRB.conf +# +# The initial entries in hash IRB.conf are determined by: +# +# - Default values. +# - Command-line options, which may override defaults. +# - Direct assignments in the configuration file. +# +# You can see the hash by typing IRB.conf. +# +# Details of the entries' meanings are described in the relevant subsections below. +# +# If you are interested in a specific entry, consult the +# {index}[rdoc-ref:doc/irb/indexes.rdoc@Index+of+IRB.conf+Entries]. +# +# === Notes on Initialization Precedence +# +# - Any conflict between an entry in hash IRB.conf and a command-line option +# is resolved in favor of the hash entry. +# - \Hash IRB.conf affects the context only once, +# when the configuration file is interpreted; +# any subsequent changes to it do not affect the context +# and are therefore essentially meaningless. +# +# === Initialization Script +# +# By default, the first command-line argument (after any options) +# is the path to a Ruby initialization script. +# +# \IRB reads the initialization script and puts its content onto the \IRB shell, +# just as if it were user-typed commands. +# +# Command-line option --noscript causes the first command-line argument +# to be treated as an ordinary argument (instead of an initialization script); +# --script is the default. +# +# == Input +# +# This section describes the features that allow you to change +# the way \IRB input works; +# see also {Input and Output}[rdoc-ref:IRB@Input+and+Output]. +# +# === Input Command History +# +# By default, \IRB stores a history of up to 1000 input commands +# in file ~/.irb_history +# (or, if a {configuration file}[rdoc-ref:IRB@Configuration+File] +# is found, in file +.irb_history+ +# inin the same directory as that file). +# +# A new \IRB session creates the history file if it does not exist, +# and appends to the file if it does exist. +# +# You can change the filepath by adding to your configuration file: +# IRB.conf[:HISTORY_FILE] = _filepath_, +# where _filepath_ is a string filepath. +# +# During the session, method conf.history_file returns the filepath, +# and method conf.history_file = new_filepath +# copies the history to the file at new_filepath, +# which becomes the history file for the session. +# +# You can change the number of commands saved by adding to your configuration file: +# IRB.conf[:SAVE_HISTORY] = _n_, +# where _n_ is one of: +# +# - Positive integer: the number of commands to be saved, +# - Zero: all commands are to be saved. +# - +nil+: no commands are to be saved,. +# +# During the session, you can use +# methods conf.save_history or conf.save_history= +# to retrieve or change the count. +# +# === Command Aliases +# +# By default, \IRB defines several command aliases: +# +# irb(main):001> conf.command_aliases +# => {:"$"=>:show_source, :"@"=>:whereami, :break=>:irb_break, :catch=>:irb_catch, :next=>:irb_next} +# +# You can change the initial aliases in the configuration file with: +# +# IRB.conf[:COMMAND_ALIASES] = {foo: :show_source, bar: :whereami} +# +# You can replace the current aliases at any time +# with configuration method conf.command_aliases=; +# Because conf.command_aliases is a hash, +# you can modify it. +# +# === End-of-File +# +# By default, IRB.conf[:IGNORE_EOF] is +false+, +# which means that typing the end-of-file character Ctrl-D +# causes the session to exit. +# +# You can reverse that behavior by adding IRB.conf[:IGNORE_EOF] = true +# to the configuration file. +# +# During the session, method conf.ignore_eof? returns the setting, +# and method conf.ignore_eof = _boolean_ sets it. +# +# === SIGINT +# +# By default, IRB.conf[:IGNORE_SIGINT] is +true+, +# which means that typing the interrupt character Ctrl-C +# causes the session to exit. +# +# You can reverse that behavior by adding IRB.conf[:IGNORE_SIGING] = false +# to the configuration file. +# +# During the session, method conf.ignore_siging? returns the setting, +# and method conf.ignore_sigint = _boolean_ sets it. +# +# === Automatic Completion +# +# By default, \IRB enables +# {automatic completion}[https://en.wikipedia.org/wiki/Autocomplete#In_command-line_interpreters]: +# +# You can disable it by either of these: +# +# - Adding IRB.conf[:USE_AUTOCOMPLETE] = false to the configuration file. +# - Giving command-line option --noautocomplete +# (--autocomplete is the default). +# +# \Method conf.use_autocomplete? returns +true+ +# if automatic completion is enabled, +false+ otherwise. +# +# The setting may not be changed during the session. +# +# === Automatic Indentation +# +# By default, \IRB automatically indents lines of code to show structure +# (e.g., it indent the contents of a block). +# +# The current setting is returned +# by the configuration method conf.auto_indent_mode. +# +# The default initial setting is +true+: +# +# irb(main):001> conf.auto_indent_mode +# => true +# irb(main):002* Dir.entries('.').select do |entry| +# irb(main):003* entry.start_with?('R') +# irb(main):004> end +# => ["README.md", "Rakefile"] +# +# You can change the initial setting in the +# configuration file with: +# +# IRB.conf[:AUTO_INDENT] = false +# +# Note that the _current_ setting may not be changed in the \IRB session. +# +# === Input \Method +# +# The \IRB input method determines how command input is to be read; +# by default, the input method for a session is IRB::RelineInputMethod. +# +# You can set the input method by: +# +# - Adding to the configuration file: +# +# - IRB.conf[:USE_SINGLELINE] = true +# or IRB.conf[:USE_MULTILINE]= false +# sets the input method to IRB::ReadlineInputMethod. +# - IRB.conf[:USE_SINGLELINE] = false +# or IRB.conf[:USE_MULTILINE] = true +# sets the input method to IRB::RelineInputMethod. +# +# - Giving command-line options: +# +# - --singleline +# or --nomultiline +# sets the input method to IRB::ReadlineInputMethod. +# - --nosingleline +# or --multiline/tt> +# sets the input method to IRB::RelineInputMethod. +# +# \Method conf.use_multiline? +# and its synonym conf.use_reline return: +# +# - +true+ if option --multiline was given. +# - +false+ if option --nomultiline was given. +# - +nil+ if neither was given. +# +# \Method conf.use_singleline? +# and its synonym conf.use_readline return: +# +# - +true+ if option --singleline was given. +# - +false+ if option --nosingleline was given. +# - +nil+ if neither was given. +# +# == Output +# +# This section describes the features that allow you to change +# the way \IRB output works; +# see also {Input and Output}[rdoc-ref:IRB@Input+and+Output]. +# +# === Return-Value Printing (Echoing) +# +# By default, \IRB prints (echoes) the values returned by all input commands. +# +# You can change the initial behavior and suppress all echoing by: +# +# - Adding to the configuration file: IRB.conf[:ECHO] = false. +# (The default value for this entry is +niL+, which means the same as +true+.) +# - Giving command-line option --noecho. +# (The default is --echo.) +# +# During the session, you can change the current setting +# with configuration method conf.echo= (set to +true+ or +false+). +# +# As stated above, by default \IRB prints the values returned by all input commands; +# but \IRB offers special treatment for values returned by assignment statements, +# which may be: +# +# - Printed with truncation (to fit on a single line of output), +# which is the default; +# an ellipsis (... is suffixed, to indicate the truncation): +# +# irb(main):001> x = 'abc' * 100 +# => "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc... +# +# - Printed in full (regardless of the length). +# - Suppressed (not printed at all) +# +# You can change the initial behavior by: +# +# - Adding to the configuration file: IRB.conf[:ECHO_ON_ASSIGNMENT] = false. +# (The default value for this entry is +niL+, which means the same as +:truncate+.) +# - Giving command-line option --noecho-on-assignment +# or --echo-on-assignment. +# (The default is --truncate-echo-on-assigment.) +# +# During the session, you can change the current setting +# with configuration method conf.echo_on_assignment= +# (set to +true+, +false+, or +:truncate+). +# +# By default, \IRB formats returned values by calling method +inspect+. +# +# You can change the initial behavior by: +# +# - Adding to the configuration file: IRB.conf[:INSPECT_MODE] = false. +# (The default value for this entry is +true+.) +# - Giving command-line option --noinspect. +# (The default is --inspect.) +# +# During the session, you can change the setting using method conf.inspect_mode=. +# +# === Multiline Output +# +# By default, \IRB prefixes a newline to a multiline response. +# +# You can change the initial default value by adding to the configuation file: +# +# IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT] = false +# +# During a session, you can retrieve or set the value using +# methods conf.newline_before_multiline_output? +# and conf.newline_before_multiline_output=. +# +# Examples: +# +# irb(main):001> conf.inspect_mode = false +# => false +# irb(main):002> "foo\nbar" +# => +# foo +# bar +# irb(main):003> conf.newline_before_multiline_output = false +# => false +# irb(main):004> "foo\nbar" +# => foo +# bar +# +# === Evaluation History +# +# By default, \IRB saves no history of evaluations (returned values), +# and the related methods conf.eval_history, _, +# and __ are undefined. +# +# You can turn on that history, and set the maximum number of evaluations to be stored: +# +# - In the configuration file: add IRB.conf[:EVAL_HISTORY] = _n_. +# (Examples below assume that we've added IRB.conf[:EVAL_HISTORY] = 5.) +# - In the session (at any time): conf.eval_history = _n_. +# +# If +n+ is zero, all evaluation history is stored. +# +# Doing either of the above: +# +# - Sets the maximum size of the evaluation history; +# defines method conf.eval_history, +# which returns the maximum size +n+ of the evaluation history: +# +# irb(main):001> conf.eval_history = 5 +# => 5 +# irb(main):002> conf.eval_history +# => 5 +# +# - Defines variable _, which contains the most recent evaluation, +# or +nil+ if none; same as method conf.last_value: +# +# irb(main):003> _ +# => 5 +# irb(main):004> :foo +# => :foo +# irb(main):005> :bar +# => :bar +# irb(main):006> _ +# => :bar +# irb(main):007> _ +# => :bar +# +# - Defines variable __: +# +# - __ unadorned: contains all evaluation history: +# +# irb(main):008> :foo +# => :foo +# irb(main):009> :bar +# => :bar +# irb(main):010> :baz +# => :baz +# irb(main):011> :bat +# => :bat +# irb(main):012> :bam +# => :bam +# irb(main):013> __ +# => +# 9 :bar +# 10 :baz +# 11 :bat +# 12 :bam +# irb(main):014> __ +# => +# 10 :baz +# 11 :bat +# 12 :bam +# 13 ...self-history... +# +# Note that when the evaluation is multiline, it is displayed differently. +# +# - __[_m_]: +# +# - Positive _m_: contains the evaluation for the given line number, +# or +nil+ if that line number is not in the evaluation history: +# +# irb(main):015> __[12] +# => :bam +# irb(main):016> __[1] +# => nil +# +# - Negative _m_: contains the +mth+-from-end evaluation, +# or +nil+ if that evaluation is not in the evaluation history: +# +# irb(main):017> __[-3] +# => :bam +# irb(main):018> __[-13] +# => nil +# +# - Zero _m_: contains +nil+: +# +# irb(main):019> __[0] +# => nil +# +# === Prompt and Return Formats +# +# By default, \IRB uses the prompt and return value formats +# defined in its +:DEFAULT+ prompt mode. +# +# ==== The Default Prompt and Return Format +# +# The default prompt and return values look like this: +# +# irb(main):001> 1 + 1 +# => 2 +# irb(main):002> 2 + 2 +# => 4 +# +# The prompt includes: +# +# - The name of the running program (irb); +# see {IRB Name}[rdoc-ref:IRB@IRB+Name]. +# - The name of the current session (main); +# See {IRB Sessions}[rdoc-ref:IRB@IRB+Sessions]. +# - A 3-digit line number (1-based). +# +# The default prompt actually defines three formats: +# +# - One for most situations (as above): +# +# irb(main):003> Dir +# => Dir +# +# - One for when the typed command is a statement continuation (adds trailing asterisk): +# +# irb(main):004* Dir. +# +# - One for when the typed command is a string continuation (adds trailing single-quote): +# +# irb(main):005' Dir.entries('. +# +# You can see the prompt change as you type the characters in the following: +# +# irb(main):001* Dir.entries('.').select do |entry| +# irb(main):002* entry.start_with?('R') +# irb(main):003> end +# => ["README.md", "Rakefile"] +# +# ==== Pre-Defined Prompts +# +# \IRB has several pre-defined prompts, stored in hash IRB.conf[:PROMPT]: +# +# irb(main):001> IRB.conf[:PROMPT].keys +# => [:NULL, :DEFAULT, :CLASSIC, :SIMPLE, :INF_RUBY, :XMP] +# +# To see the full data for these, type IRB.conf[:PROMPT]. +# +# Most of these prompt definitions include specifiers that represent +# values like the \IRB name, session name, and line number; +# see {Prompt Specifiers}[rdoc-ref:IRB@Prompt+Specifiers]. +# +# You can change the initial prompt and return format by: +# +# - Adding to the configuration file: IRB.conf[:PROMPT] = _mode_ +# where _mode_ is the symbol name of a prompt mode. +# - Giving a command-line option: +# +# - --prompt _mode_: sets the prompt mode to _mode_. +# where _mode_ is the symbol name of a prompt mode. +# - --simple-prompt or --sample-book-mode: +# sets the prompt mode to +:SIMPLE+. +# - --inf-ruby-mode: sets the prompt mode to +:INF_RUBY+ +# and suppresses both --multiline and --singleline. +# - --noprompt: suppresses prompting; does not affect echoing. +# +# You can retrieve or set the current prompt mode with methods +# +# conf.prompt_mode and conf.prompt_mode=. +# +# If you're interested in prompts and return formats other than the defaults, +# you might experiment by trying some of the others. +# +# ==== Custom Prompts +# +# You can also define custom prompts and return formats, +# which may be done either in an \IRB session or in the configuration file. +# +# A prompt in \IRB actually defines three prompts, as seen above. +# For simple custom data, we'll make all three the same: +# +# irb(main):001* IRB.conf[:PROMPT][:MY_PROMPT] = { +# irb(main):002* PROMPT_I: ': ', +# irb(main):003* PROMPT_C: ': ', +# irb(main):004* PROMPT_S: ': ', +# irb(main):005* RETURN: '=> ' +# irb(main):006> } +# => {:PROMPT_I=>": ", :PROMPT_C=>": ", :PROMPT_S=>": ", :RETURN=>"=> "} +# +# If you define the custom prompt in the configuration file, +# you can also make it the current prompt by adding: +# +# IRB.conf[:PROMPT_MODE] = :MY_PROMPT +# +# Regardless of where it's defined, you can make it the current prompt in a session: +# +# conf.prompt_mode = :MY_PROMPT +# +# You can view or modify the current prompt data with various configuration methods: +# +# - conf.prompt_mode, conf.prompt_mode=. +# - conf.prompt_c, conf.c=. +# - conf.prompt_i, conf.i=. +# - conf.prompt_s, conf.s=. +# - conf.return_format, return_format=. +# +# ==== Prompt Specifiers +# +# A prompt's definition can include specifiers for which certain values are substituted: +# +# - %N: the name of the running program. +# - %m: the value of self.to_s. +# - %M: the value of self.inspect. +# - %l: an indication of the type of string; +# one of ", ', /, ]. +# - NNi: Indentation level. +# - NNn: Line number. +# - %%: Literal %. +# +# === Verbosity +# +# By default, \IRB verbosity is disabled, which means that output is smaller +# rather than larger. +# +# You can enable verbosity by: +# +# - Adding to the configuration file: IRB.conf[:VERBOSE] = true +# (the default is +nil+). +# - Giving command-line options --verbose +# (the default is --noverbose). +# +# During a session, you can retrieve or set verbosity with methods +# conf.verbose and conf.verbose=. +# +# === Help +# +# Command-line option --version causes \IRB to print its help text +# and exit. +# +# === Version +# +# Command-line option --version causes \IRB to print its version text +# and exit. +# +# == Input and Output +# +# === \Color Highlighting +# +# By default, \IRB color highlighting is enabled, and is used for both: +# +# - Input: As you type, \IRB reads the typed characters and highlights +# elements that it recognizes; +# it also highlights errors such as mismatched parentheses. +# - Output: \IRB highlights syntactical elements. +# +# You can disable color highlighting by: +# +# - Adding to the configuration file: IRB.conf[:USE_COLORIZE] = false +# (the default value is +true+). +# - Giving command-line option --nocolorize +# +# == Debugging +# +# Command-line option -d sets variables $VERBOSE +# and $DEBUG to +true+; +# these have no effect on \IRB output. +# +# === Tracer +# +# \IRB's tracer feature controls whether a stack trace +# is to be displayed for each command. +# +# Command-line option -tracer sets +# variable IRB.conf[:USE_TRACER] to +true+ +# (the default is +false+). +# +# You can specify a back trace limit, +n+, +# which specifies that the back trace for an exception +# can contain no more than 2 * +n+ entries, +# consisting at most of the first +n+ and last +n+ entries. +# +# The current limit is returned +# by the configuration method conf.back_trace_limit. +# +# The initial limit is 16: +# +# irb(main):001> conf.back_trace_limit +# => 16 +# +# You can change the initial limit with command-line option +# --back-trace-limit _value_: +# +# irb --back-trace-limit 32 +# +# You can also change the initial limit in the configuration file +# (which overrides the command-line option above): +# +# IRB.conf[:BACK_TRACE_LIMIT] = 24 +# +# You can change the current limit at any time +# with configuration method conf.back_trace_limit=. +# +# Note that the _current_ limit may not +# be changed by IRB.conf[:BACK_TRACE_LIMIT] = '_value_' +# in the \IRB session. +# +# === Warnings +# +# Command-line option -w suppresses warnings. +# +# Command-line option -W[_level_] +# sets warning level; 0=silence, 1=medium, 2=verbose. +# +# :stopdoc: +# === Performance Measurement +# +# IRB.conf[:MEASURE] IRB.conf[:MEASURE_CALLBACKS] IRB.conf[:MEASURE_PROC] +# :startdoc: +# +# == Other Features +# +# === Load Modules +# +# You can specify the names of modules that are to be required at startup. +# +# \Array conf.load_modules determines the modules (if any) +# that are to be required during session startup. +# The array is used only during session startup, +# so the initial value is the only one that counts. +# +# The default initial value is [] (load no modules): +# +# irb(main):001> conf.load_modules +# => [] +# +# You can set the default initial value via: +# +# - Command-line option -r +# +# $ irb -r csv -r json +# irb(main):001> conf.load_modules +# => ["csv", "json"] +# +# - \Hash entry IRB.conf[:LOAD_MODULES] = _array_: +# +# IRB.conf[:LOAD_MODULES] = %w[csv, json] +# +# Note that the configuration file entry overrides the command-line options. +# +# :stopdoc: +# === \IRB Loader +# +# IRB.conf[:USE_LOADER] +# :startdoc: +# +# === RI Documentation Directories +# +# You can specify the paths to RI documentation directories +# that are to be loaded (in addition to the default directories) at startup; +# see details about RI by typing ri --help. +# +# \Array conf.extra_doc_dirs determines the directories (if any) +# that are to be loaded during session startup. +# The array is used only during session startup, +# so the initial value is the only one that counts. +# +# The default initial value is [] (load no extra documentation): +# +# irb(main):001> conf.extra_doc_dirs +# => [] +# +# You can set the default initial value via: +# +# - Command-line option --extra_doc_dir +# +# $ irb --extra-doc-dir your_doc_dir --extra-doc-dir my_doc_dir +# irb(main):001> conf.extra_doc_dirs +# => ["your_doc_dir", "my_doc_dir"] +# +# - \Hash entry IRB.conf[:EXTRA_DOC_DIRS] = _array_: +# +# IRB.conf[:EXTRA_DOC_DIRS] = %w[your_doc_dir my_doc_dir] +# +# Note that the configuration file entry overrides the command-line options. +# +# :stopdoc: +# === \Context Mode +# +# IRB.conf[:CONTEXT_MODE] +# :startdoc: +# +# === \IRB Name +# +# You can specify a name for \IRB. +# +# The default initial value is 'irb': +# +# irb(main):001> conf.irb_name +# => "irb" +# +# You can set the default initial value +# via hash entry IRB.conf[:IRB_NAME] = _string_: +# +# IRB.conf[:IRB_NAME] = 'foo' +# +# === Application Name +# +# You can specify an application name for the \IRB session. +# +# The default initial value is 'irb': +# +# irb(main):001> conf.ap_name +# => "irb" +# +# You can set the default initial value +# via hash entry IRB.conf[:AP_NAME] = _string_: +# +# IRB.conf[:AP_NAME] = 'my_ap_name' +# +# :stopdoc: +# === \IRB Library Directory +# +# IRB.conf[:IRB_LIB_PATH] +# :startdoc: +# +# === Configuration Monitor +# +# You can monitor changes to the configuration by assigning a proc +# to IRB.conf[:IRB_RC] in the configuration file: +# +# IRB.conf[:IRB_RC] = proc {|conf| puts conf.class } +# +# Each time the configuration is changed, +# that proc is called with argument +conf+: +# +# :stopdoc: +# === \Locale +# +# IRB.conf[:LC_MESSAGES] +# :startdoc: +# +# :stopdoc: +# === Single-IRB Mode +# +# IRB.conf[:SINGLE_IRB] +# :startdoc: +# +# === Encodings +# +# Command-line option -E _ex_[:_in_] +# sets initial external (ex) and internal (in) encodings. +# +# Command-line option -U sets both to UTF-8. +# +# === Commands # # The following commands are available on IRB. # @@ -97,169 +931,14 @@ # * break, delete, next, step, continue, finish, backtrace, info, catch # * Start the debugger of debug.gem and run the command on it. # -# == Configuration -# -# IRB reads a personal initialization file when it's invoked. -# IRB searches a file in the following order and loads the first one found. -# -# * $IRBRC (if $IRBRC is set) -# * $XDG_CONFIG_HOME/irb/irbrc (if $XDG_CONFIG_HOME is set) -# * ~/.irbrc -# * +.config/irb/irbrc+ -# * +.irbrc+ -# * +irb.rc+ -# * +_irbrc+ -# * $irbrc -# -# The following are alternatives to the command line options. To use them type -# as follows in an +irb+ session: -# -# IRB.conf[:IRB_NAME]="irb" -# IRB.conf[:INSPECT_MODE]=nil -# IRB.conf[:IRB_RC] = nil -# IRB.conf[:BACK_TRACE_LIMIT]=16 -# IRB.conf[:USE_LOADER] = false -# IRB.conf[:USE_MULTILINE] = nil -# IRB.conf[:USE_SINGLELINE] = nil -# IRB.conf[:USE_COLORIZE] = true -# IRB.conf[:USE_TRACER] = false -# IRB.conf[:USE_AUTOCOMPLETE] = true -# IRB.conf[:IGNORE_SIGINT] = true -# IRB.conf[:IGNORE_EOF] = false -# IRB.conf[:PROMPT_MODE] = :DEFAULT -# IRB.conf[:PROMPT] = {...} -# -# === Auto indentation -# -# To disable auto-indent mode in irb, add the following to your +.irbrc+: -# -# IRB.conf[:AUTO_INDENT] = false -# -# === Autocompletion -# -# To disable autocompletion for irb, add the following to your +.irbrc+: -# -# IRB.conf[:USE_AUTOCOMPLETE] = false -# -# To enable enhanced completion using type information, add the following to your +.irbrc+: -# -# IRB.conf[:COMPLETOR] = :type -# -# === History -# -# By default, irb will store the last 1000 commands you used in -# IRB.conf[:HISTORY_FILE] (~/.irb_history by default). -# -# If you want to disable history, add the following to your +.irbrc+: -# -# IRB.conf[:SAVE_HISTORY] = nil -# -# See IRB::Context#save_history= for more information. -# -# The history of _results_ of commands evaluated is not stored by default, -# but can be turned on to be stored with this +.irbrc+ setting: -# -# IRB.conf[:EVAL_HISTORY] = -# -# See IRB::Context#eval_history= and EvalHistory class. The history of command -# results is not permanently saved in any file. -# -# == Customizing the IRB Prompt -# -# In order to customize the prompt, you can change the following Hash: -# -# IRB.conf[:PROMPT] -# -# This example can be used in your +.irbrc+ -# -# IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode -# :AUTO_INDENT => false, # disables auto-indent mode -# :PROMPT_I => ">> ", # simple prompt -# :PROMPT_S => nil, # prompt for continuated strings -# :PROMPT_C => nil, # prompt for continuated statement -# :RETURN => " ==>%s\n" # format to return value -# } -# -# IRB.conf[:PROMPT_MODE] = :MY_PROMPT -# -# Or, invoke irb with the above prompt mode by: -# -# irb --prompt my-prompt -# -# Constants +PROMPT_I+, +PROMPT_S+ and +PROMPT_C+ specify the format. In the -# prompt specification, some special strings are available: -# -# %N # command name which is running -# %m # to_s of main object (self) -# %M # inspect of main object (self) -# %l # type of string(", ', /, ]), `]' is inner %w[...] -# %NNi # indent level. NN is digits and means as same as printf("%NNd"). -# # It can be omitted -# %NNn # line number. -# %% # % -# -# For instance, the default prompt mode is defined as follows: -# -# IRB.conf[:PROMPT_MODE][:DEFAULT] = { -# :PROMPT_I => "%N(%m):%03n> ", -# :PROMPT_S => "%N(%m):%03n%l ", -# :PROMPT_C => "%N(%m):%03n* ", -# :RETURN => "%s\n" # used to printf -# } -# -# irb comes with a number of available modes: -# -# # :NULL: -# # :PROMPT_I: -# # :PROMPT_S: -# # :PROMPT_C: -# # :RETURN: | -# # %s -# # :DEFAULT: -# # :PROMPT_I: ! '%N(%m):%03n> ' -# # :PROMPT_S: ! '%N(%m):%03n%l ' -# # :PROMPT_C: ! '%N(%m):%03n* ' -# # :RETURN: | -# # => %s -# # :CLASSIC: -# # :PROMPT_I: ! '%N(%m):%03n:%i> ' -# # :PROMPT_S: ! '%N(%m):%03n:%i%l ' -# # :PROMPT_C: ! '%N(%m):%03n:%i* ' -# # :RETURN: | -# # %s -# # :SIMPLE: -# # :PROMPT_I: ! '>> ' -# # :PROMPT_S: -# # :PROMPT_C: ! '?> ' -# # :RETURN: | -# # => %s -# # :INF_RUBY: -# # :PROMPT_I: ! '%N(%m):%03n> ' -# # :PROMPT_S: -# # :PROMPT_C: -# # :RETURN: | -# # %s -# # :AUTO_INDENT: true -# # :XMP: -# # :PROMPT_I: -# # :PROMPT_S: -# # :PROMPT_C: -# # :RETURN: |2 -# # ==>%s -# -# == Restrictions -# -# Because irb evaluates input immediately after it is syntactically complete, -# the results may be slightly different than directly using Ruby. -# -# == IRB Sessions +# === IRB Sessions # # IRB has a special feature, that allows you to manage many sessions at once. # # You can create new sessions with Irb.irb, and get a list of current sessions # with the +jobs+ command in the prompt. # -# === Commands +# ==== \IRB-Specific Commands # # JobManager provides commands to handle the current sessions: # @@ -280,19 +959,19 @@ # +irb_require+:: # Loads the given file similarly to Kernel#require # -# === Configuration +# ==== Configuration # # The command line options, or IRB.conf, specify the default behavior of # Irb.irb. # -# On the other hand, each conf in IRB@Command+line+options is used to +# On the other hand, each conf in IRB@Command-Line+Options is used to # individually configure IRB.irb. # # If a proc is set for IRB.conf[:IRB_RC], its will be invoked after execution # of that proc with the context of the current session as its argument. Each # session can be configured using this mechanism. # -# === Session variables +# ==== Session variables # # There are a few variables in every Irb session that can come in handy: # @@ -307,7 +986,7 @@ # If +line_no+ is a negative, the return value +line_no+ many lines before # the most recent return value. # -# === Example using IRB Sessions +# ==== Example using IRB Sessions # # # invoke a new session # irb(main):001:0> irb @@ -367,6 +1046,15 @@ # #0->irb on main (# : running) # # quit irb # irb(main):010:0> exit +# +# == Restrictions +# +# Ruby code typed into \IRB behaves the same as Ruby code in a file, except that: +# +# - Because \IRB evaluates input immediately after it is syntactically complete, +# some results may be slightly different. +# - Forking may not be well behaved. +# module IRB # An exception raised by IRB.irb_abort @@ -1023,8 +1711,7 @@ class Binding # irb(#):005:0> exit # Cooked potato: true # - # - # See IRB@Usage for more information. + # See IRB for more information. def irb(show_code: true) # Setup IRB with the current file's path and no command line arguments IRB.setup(source_location[0], argv: []) diff --git a/lib/irb/context.rb b/lib/irb/context.rb index ffbba4e8b..c3690fcac 100644 --- a/lib/irb/context.rb +++ b/lib/irb/context.rb @@ -264,15 +264,15 @@ def main attr_reader :prompt_mode # Standard IRB prompt. # - # See IRB@Customizing+the+IRB+Prompt for more information. + # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information. attr_accessor :prompt_i # IRB prompt for continuated strings. # - # See IRB@Customizing+the+IRB+Prompt for more information. + # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information. attr_accessor :prompt_s # IRB prompt for continuated statement. (e.g. immediately after an +if+) # - # See IRB@Customizing+the+IRB+Prompt for more information. + # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information. attr_accessor :prompt_c # TODO: Remove this when developing v2.0 @@ -394,8 +394,6 @@ def prompt_n=(_) # The default value is 16. # # Can also be set using the +--back-trace-limit+ command line option. - # - # See IRB@Command+line+options for more command line options. attr_accessor :back_trace_limit # User-defined IRB command aliases @@ -463,7 +461,7 @@ def set_last_value(value) # Sets the +mode+ of the prompt in this context. # - # See IRB@Customizing+the+IRB+Prompt for more information. + # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information. def prompt_mode=(mode) @prompt_mode = mode pconf = IRB.conf[:PROMPT][mode] @@ -501,8 +499,6 @@ def file_input? # # Can also be set using the +--inspect+ and +--noinspect+ command line # options. - # - # See IRB@Command+line+options for more command line options. def inspect_mode=(opt) if i = Inspector::INSPECTORS[opt] diff --git a/lib/irb/help.rb b/lib/irb/help.rb index ca12810de..6861d7efc 100644 --- a/lib/irb/help.rb +++ b/lib/irb/help.rb @@ -5,7 +5,7 @@ # module IRB - # Outputs the irb help message, see IRB@Command+line+options. + # Outputs the irb help message, see IRB@Command-Line+Options. def IRB.print_usage lc = IRB.conf[:LC_MESSAGES] path = lc.find("irb/help-message") diff --git a/lib/irb/xmp.rb b/lib/irb/xmp.rb index 94c700b48..de2908942 100644 --- a/lib/irb/xmp.rb +++ b/lib/irb/xmp.rb @@ -44,8 +44,8 @@ class XMP # The top-level binding or, optional +bind+ parameter will be used when # creating the workspace. See WorkSpace.new for more information. # - # This uses the +:XMP+ prompt mode, see IRB@Customizing+the+IRB+Prompt for - # full detail. + # This uses the +:XMP+ prompt mode. + # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information. def initialize(bind = nil) IRB.init_config(nil)