NAME
jruby - Interpreted object-oriented scripting language
SYNOPSIS
jruby [--copyright] [--version] [-Sacdlnpswvy] [-0[octal]] [-C directory]
[-F pattern] [-I directory] [-K c] [-T[level]] [-e command]
[-i[extension]] [-r library] [-x[directory]] [--] [program_file]
[argument ...]
DESCRIPTION
Jruby is a 100% pure-Java implementation of Ruby, an interpreted
scripting language for quick and easy object-oriented programming. It
has many features to process text files and to do system management tasks
(as in Perl). It is simple, straight-forward, and extensible.
OPTIONS
Ruby interpreter accepts following command-line options (switches). They
are quite similar to those of perl(1).
--copyright Prints the copyright notice.
--version Prints the version of Ruby interpreter.
-0[octal] (The digit “zero”.) Specifies the input record separator
($/) as an octal number. If no digit is given, the null
character is taken as the separator. Other switches may
follow the digits. -00 turns Ruby into paragraph mode.
-0777 makes Ruby read whole file at once as a single
string since there is no legal character with that value.
-C directory Causes Ruby to switch to the directory.
-F pattern Specifies input field separator ($;).
-I directory Used to tell Ruby where to load the library scripts.
Directory path will be added to the load-path variable
($:).
-K kcode Specifies KANJI (Japanese) encoding.
-S Makes Ruby use the PATH environment variable to search for
script, unless if its name begins with a slash. This is
used to emulate #! on machines that don’t support it, in
the following manner:
#! /usr/local/bin/ruby
# This line makes the next one a comment in Ruby \
exec /usr/local/bin/ruby -S $0 $*
-T[level] Turns on taint checks at the specified level (default 1).
-a Turns on auto-split mode when used with -n or -p. In
auto-split mode, Ruby executes
$F = $_.split
at beginning of each loop.
-c Causes Ruby to check the syntax of the script and exit
without executing. If there are no syntax errors, Ruby
will print “Syntax OK” to the standard output.
-d
--debug Turns on debug mode. $DEBUG will be set to true.
-e command Specifies script from command-line while telling Ruby not
to search the rest of arguments for a script file name.
-h
--help Prints a summary of the options.
-i extension Specifies in-place-edit mode. The extension, if
specified, is added to old file name to make a backup
copy. For example:
% echo matz > /tmp/junk
% cat /tmp/junk
matz
% ruby -p -i.bak -e ’$_.upcase!’ /tmp/junk
% cat /tmp/junk
MATZ
% cat /tmp/junk.bak
matz
-l (The lowercase letter “ell”.) Enables automatic line-
ending processing, which means to firstly set $\ to the
value of $/, and secondly chops every line read using
chop!.
-n Causes Ruby to assume the following loop around your
script, which makes it iterate over file name arguments
somewhat like sed -n or awk.
while gets
...
end
-p Acts mostly same as -n switch, but print the value of
variable $_ at the each end of the loop. For example:
% echo matz | ruby -p -e ’$_.tr! "a-z", "A-Z"’
MATZ
-r library Causes Ruby to load the library using require. It is
useful when using -n or -p.
-s Enables some switch parsing for switches after script name
but before any file name arguments (or before a --). Any
switches found there are removed from ARGV and set the
corresponding variable in the script. For example:
#! /usr/local/bin/ruby -s
# prints "true" if invoked with ‘-xyz’ switch.
print "true\n" if $xyz
On some systems $0 does not always contain the full
pathname, so you need the -S switch to tell Ruby to search
for the script if necessary. To handle embedded spaces or
such. A better construct than $* would be ${1+"$@"}, but
it does not work if the script is being interpreted by
csh(1).
-v
--verbose Enables verbose mode. Ruby will print its version at the
beginning, and set the variable $VERBOSE to true. Some
methods print extra messages if this variable is true. If
this switch is given, and no other switches are present,
Ruby quits after printing its version.
-w Enables verbose mode without printing version message at
the beginning. It sets the $VERBOSE variable to true.
-x[directory] Tells Ruby that the script is embedded in a message.
Leading garbage will be discarded until the first that
starts with “#!” and contains the string, “ruby”. Any
meaningful switches on that line will applied. The end of
script must be specified with either EOF, ^D (control-D),
^Z (control-Z), or reserved word __END__. If the
directory name is specified, Ruby will switch to that
directory before executing script.
-y
--yydebug Turns on compiler debug mode. Ruby will print a bunch of
internal state messages during compiling scripts. You
don’t have to specify this switch, unless you are going to
debug the Ruby interpreter.