Man page - jruby(1)

Packages contains this manual

Manual

JRUBY(1) () LOCAL JRUBY(1) ()

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. UNIX Apr 2, 2007 JRUBY(1) ()