     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 programming,
     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.  Ruby's features are as follows: Ruby is an  interpreted  language,
     so  you  don't  have to recompile programs written in Ruby to execute them.
     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.
     You can use variables in  your  Ruby  programs  without  any  declarations.
     Variable  names denote their scope, local, global, instance, etc.  Ruby has
     a simple syntax influenced slightly from Eiffel.  Ruby has automatic memory
     management.   Objects  no longer referenced from anywhere are automatically
     collected by the garbage collector built into the interpreter.  Ruby is the
     purely  object-oriented language, and was so since its creation.  Even such
     basic data as integers are seen as  objects.   Of  course,  as  an  object-
     oriented  language, Ruby has such basic features like classes, inheritance,
     and methods.  Ruby has the ability to define methods for  certain  objects.
     For  example,  you  can  define a press-button action for certain widget by
     defining a singleton method for the button.  Or, you can make up  your  own
     prototype  based  object  system  using  singleton methods, if you want to.
     Ruby intentionally does not have the multiple inheritance as it is a source
     of  confusion.   Instead,  Ruby  has  the  ability to share implementations
     across the inheritance tree.  This is often called Ruby has  iterators  for
     loop  abstraction.   In  Ruby, you can objectify the procedure.  Ruby has a
     bunch of text processing features like in Perl.  With built-in bignums, you
     can  for  example  calculate factorial(400).  As in Java(tm).  Ruby can use
     most system calls, often used in system programming.  On most systems,  you
     can   load  object  files  into  the  Ruby  interpreter  on-the-fly.   Ruby
     interpreter accepts following command-line options  (switches).   They  are
     quite  similar to those of Prints the copyright notice.  Prints the version
     of Ruby interpreter.  (The digit 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.   turns  Ruby  into
     paragraph  mode.   makes  Ruby  read  whole file at once as a single string
     since there is no legal character with that value.  Causes Ruby  to  switch
     to  the directory.  Specifies input field separator Used to tell Ruby where
     to load the library scripts.  Directory path will be added to the load-path
     variable   Specifies   KANJI  (Japanese)  encoding.   Makes  Ruby  use  the
     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 $* Turns on taint checks at the  specified
     level  (default  1).   Turns  on auto-split mode when used with or In auto-
     split mode, Ruby executes at beginning of each loop.  Causes Ruby to  check
     the syntax of the script and exit without executing. If there are no syntax
     errors, Ruby will print to the standard output.  Turns on debug mode.  will
     be  set to true.  Specifies script from command-line while telling Ruby not
     to search the rest of arguments for a script file name.  Prints  a  summary
     of   the   options.   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  (The  lowercase
     letter Enables automatic line-ending processing, which means to firstly set
     to the value of and secondly chops every line read  using  Causes  Ruby  to
     assume  the  following loop around your script, which makes it iterate over
     file name arguments somewhat like or while gets
       ...  end 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 Causes Ruby to load the library using  require.   It  is
     useful  when using or 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 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 does not always
     contain the full pathname, so you need the switch to tell  Ruby  to  search
     for  the script if necessary.  To handle embedded spaces or such.  A better
     construct than would be but it  does  not  work  if  the  script  is  being
     interpreted  by  Enables  verbose mode.  Ruby will print its version at the
     beginning, and set the variable 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.  Enables  verbose  mode
     without printing version message at the beginning.  It sets the variable to
     true.  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, Any meaningful switches on that line  will  applied.   The  end  of
     script must be specified with either or reserved word If the directory name
     is specified, Ruby will switch to that directory before  executing  script.
     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.  A colon-separated list
     of directories  that  are  appended  to  Ruby's  library  load  path  e.g.:
     Additional  Ruby options.  e.g.  A colon-separated list of directories that
     Ruby searches for Ruby programs when the flag is specified.  This  variable
     precedes  the  environment variable.  The path to the system shell command.
     This environment variable is enabled for only mswin32,  mingw32,  and  OS/2
     platforms.   If this variable is not defined, Ruby refers to Ruby refers to
     the environment  variable  on  calling  Kernel#system.   This  variable  is
     obsolete.  Ruby is designed and implemented by