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)()