jruby1.1

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 script‐
     ing 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 speci‐
                    fied, 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-end‐
                    ing 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 use‐
                    ful 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 path‐
                    name, 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 direc‐
                    tory 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                             UNIX