ruby1.9.3(1) - Interpreted object-oriented scripting language
--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
-X directory   Causes Ruby to switch to the directory.
-E external[:internal]
--encoding external[:internal]
               Specifies the default value(s) for external encodings and internal encoding. Values should
               be separated with colon (:).

               You can omit the one for internal encodings, then the value (Encoding.default_internal) will
               be nil.
-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. The default value for script encodings (__ENCODING__)
               and external encodings (Encoding.default_external) will be the specified one. kcode can be
               one of

                     e       EUC-JP

                     s       Windows-31J (CP932)

                     u       UTF-8

                     n       ASCII-8BIT (BINARY)
-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=1]    Turns on taint checks at the specified level (default 1).
-U             Sets the default value for internal encodings (Encoding.default_internal) to UTF-8.
-W[level=2]    Turns on verbose mode at the specified level, without printing version message at the
               beginning. The level can be;

                     0       Verbose mode is "silence". It sets the $VERBOSE to nil.

                     1       Verbose mode is "medium". It sets the $VERBOSE to false.

                     2 (default) Verbose mode is "verbose". It sets the $VERBOSE to true.  -W2 is same as
                             -w
-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 the
               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             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 the reserved word __END__.  If the directory name is
               specified, Ruby will switch to that directory before executing script.
-y
--yydebug      DO NOT USE.

               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.
--disable-FEATURE
--enable-FEATURE
               Disables (or enables) the specified FEATURE.
               --disable-gems
               --enable-gems      Disables (or enables) RubyGems libraries.  By default, Ruby will load the
                                  latest version of each installed gem. The Gem constant is true if
                                  RubyGems is enabled, false if otherwise.
--disable-rubyopt
--enable-rubyopt   Ignores (or considers) the RUBYOPT environment variable. By default, Ruby
                   considers the variable.
--disable-all
--enable-all       Disables (or enables) all features.
--dump=target  DO NOT USE.

               Prints the specified target.  target can be one of;

                     insns   disassembled instructions

               You don't have to specify this switch, unless you are going to debug the Ruby interpreter.
--verbose      Enables verbose mode without printing version message at the beginning.  It sets the
               $VERBOSE variable to true.  If this switch is given, and no other switches are present, Ruby
               quits after printing its version.