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
" 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 spec-
		    ified 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 							      UNIX