Gavin Sinclair graced us by uttering:
[ snippage ]
> Ruby doesn't even *have* a manpage on my system (Cygwin).  A
> basic manpage containing links to the online book, ruby-talk,
> etc. would be a start.

I wouldn't want Gavin to miss out, so here's the ruby manpage
from my linux box.  :)

Sadly, there's still no links to the sites mentioned above.

% ruby --version
ruby 1.6.7 (2002-03-01) [i686-linux]
% man ruby

-------------------- BEGIN `man ruby` --------------------

RUBY(1)         Ruby Programmers Reference Manual         RUBY(1)



NAME
       ruby - Interpreted object-oriented scripting language

SYNOPSIS
       ruby   [ --version ]  [ -c ]  [ -w ]  [ -d ]  [ -l ]
              [ -p ]  [ -n ]  [ -a ]  [ -s ]  [ -0[octal] ]
              [ -Kc ]  [ -ecommand ]  [ -Fpattern ]
              [ -i[extension] ]  [ -Idir ] [ -rlibrary ]
              [ -S ]  [ -v ]  [ -x[directory] ]  [ -Cdirectory ]
              [ -y] [ -- ] [ programfile ]  [ argument ] ...


PREFACE
       Ruby is 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.

       If you want a language for easy object-oriented program       ming, or you don't like the Perl ugliness, or you do like
       the concept of lisp, but don't like too much parentheses,
       Ruby may be the language of your choice.

DESCRIPTION
       Ruby's features are as follows:

       Interpretive
              Ruby is an interpreted language, so you don't have
              to recompile programs written in Ruby to execute
              them.

       Variables have no type (dynamic typing)
              Variables in Ruby can contain data of any type.
              You don't have to worry about variable typing.
              Consequently, it has a weaker compile time check.

       No declaration needed
              You can use variables in your Ruby programs without
              any declarations.  Variable names denote their
              scope, local, global, instance, etc.

       Simple syntax
              Ruby has a simple syntax influenced slightly from
              Eiffel.

       No user-level memory management
              Ruby has automatic memory management. Objects no
              longer referenced from anywhere are automatically
              collected by the garbage collector built into the
              interpreter.

       Everything is an object
              Ruby is the purely object-oriented language, and
              was so since its creation.  Even such basic data as
              integers are seen as objects.

       Class, inheritance, methods
              Of course, as an object-oriented language, Ruby has
              such basic features like classes, inheritance, and
              methods.

       Singleton methods
              Ruby has the ability to define methods for certain
              objects.  For example, you can define a press-but              ton action for certain widget by defining a single              ton method for the button.  Or, you can make up
              your own prototype based object system using sin              gleton methods, if you want to.

       Mix-in by modules
              Ruby intentionally does not have the multiple
              inheritance as it is a source of confusion.
              Instead, Ruby has the ability to share implementa              tions across the inheritance tree.  This is often
              called `Mix-in'.

       Iterators
              Ruby has iterators for loop abstraction.

       Closures
              In Ruby, you can objectify the procedure.

       Text processing and regular expression
              Ruby has a bunch of text processing features like
              in Perl.

       Bignums
              With built-in bignums, you can for example calcu              late factorial(400).

       Exception handling
              As in Java(tm).

       Direct access to the OS
              Ruby can use most UNIX system calls, often used in
              system programming.

       Dynamic loading
              On most UNIX systems, you can load object files
              into the Ruby interpreter on-the-fly.


COMMAND LINE OPTIONS
       Ruby interpreter accepts following command-line options
       (switches).  They are quite similar to those of Perl.

       -0[octal]
              specifies the input record separator ($/) as an
              octal number. If no digit is given, the null char              acter is taken as the separator.  Other switches
              may follow the digits.  -00 turns Ruby into para              graph mode.  - 0777 makes Ruby read whole file at
              once as a single string since there is no legal
              character with that value.

       -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.

       --copyright
              prints the copyright notice.

       -d --debug
              turns on debug mode. $DEBUG will set true.

       -e command
              specifies script from command-line while telling
              Ruby to not search argv for script filenames.

       -F pattern
              specifies input field separator ($;).

       -h --help
              prints a summary of the options.

       -i extension
              specifies in-place-edit mode. The extension, if
              specified, is added to old filename to make a
              backup copy.  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

       -I directory
              used to tell Ruby where to load the library
              scripts. Directory path will be added to the load-
              path variable ($:').

       -Kkcode
              specifies KANJI (Japanese) encoding.

       -l     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 filename
              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.  exam              ple:
                  % echo matz | ruby -p -e '$_.tr! "a-z", "A-Z"'
                  MATZ

       -r library
              causes Ruby to load the library using require. It
              is useful with switches -n or -p.

       -s     enables some switch parsing for switches after
              script name but before any filename arguments (or
              before a --). Any switches found there are removed
              from ARGV and set the corresponding variable in the
              script.  example:
                  #! /usr/local/bin/ruby -s
                  # prints "true" if invoked with `-xyz' switch.
                  print "true\n" if $xyz

       -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 $*
              On some systems $0 does not always contain the full
              pathname, so you need -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.

       -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 print              ing its version.

       -T[level]
              turns on taint checks at the specified level
              (default 1).

       --version
              prints the version of Ruby interpreter.

       -w     enables verbose mode without printing version mes              sage at the beginning. It set the `$VERBOSE' vari              able to true.

       -x[directory]
              tells Ruby that the script is embedded in a mes              sage. 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.

       -C directory
              causes Ruby to switch to the directory.

       -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.


AUTHOR
        Ruby is designed and implemented by Yukihiro Matsumoto
       <matz / netlab.jp>.



2001-12-25                   ruby 1.6                     RUBY(1)

-------------------- END `man ruby` --------------------

Tim Hammerquist
-- 
Look at my hopes. Look at my dreams.
The currency we've spent.
I love you.
You pay my rent.
    -- The Pet Shop Boys, "Rent"