ruby man page on JazzOS

Man page or keyword search:  
man Server   2339 pages
apropos Keyword Search (all sections)
Output format
JazzOS logo
[printable version]

RUBY(1)				     UNIX			       RUBY(1)

       ruby - Interpreted object-oriented scripting language

       ruby  [--copyright]  [--version]	 [-Sacdlnpswvy] [-0[octal]] [-C direc‐
       tory] [-F pattern] [-I  directory]  [-K	c]  [-T[level]]	 [-e  command]
       [-i[extension]] [-r library] [-x[directory]] [--] [program_file] [argu‐
       ment ...]

       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

       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 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 declara‐
	      tions.   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 refer‐
	      enced 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

       Class, inheritance, and 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-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 meth‐
	      ods, 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 implementations across  the	 inheritance  tree.   This  is
	      often called `Mix-in'.

	      Ruby has iterators for loop abstraction.

	      In Ruby, you can objectify the procedure.

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

	      With  built-in  bignums,	you  can  for example calculate facto‐

       Exception handling
	      As in Java(tm).

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

       Dynamic loading
	      On  most	UNIX  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 perl(1).

	      Prints the copyright notice.

	      Prints the version of Ruby interpreter.

	      (The  digit  ``zero''.)	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 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

	      #! /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).

       -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 ``Syn‐
	      tax OK'' to the standard output.


	      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.


       --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
	      % ruby -p -i.bak -e '$_.upcase!' /tmp/junk
	      % cat /tmp/junk
	      % cat /tmp/junk.bak

       -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

       -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 '$! "a-z", "A-Z"'

       -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 con‐
	      struct than "$*" would be ${1+"$@"}, but it does not work if the
	      script is being interpreted by csh(1).


	      Enables verbose mode.  Ruby will print its version at the begin‐
	      ning,  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.

	      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	speci‐
	      fied,  Ruby  will	 switch	 to  that  directory  before executing


	      Turns on compiler debug mode.  Ruby will print a bunch of inter‐
	      nal  state messages during compiling scripts.  You don't have to
	      specify this switch, unless you are  going  to  debug  the  Ruby

	      A	 colon-separated  list of directories that are added to Ruby's
	      library load path	 ("$:").  Directories  from  this  environment
	      variable are searched before the standard load path is searched.


	      Additional Ruby options.

		RUBYOPT="-w -Ke"

	      A	 colon-separated  list	of  directories that Ruby searches for
	      Ruby programs when the -S flag is specified.  This variable pre‐
	      cedes the PATH 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 COMSPEC.

       PATH   Ruby  refers  to	the  PATH environment variable on calling Ker‐

	      This variable is obsolete.

       Ruby is designed	 and  implemented  by  Yukihiro	 Matsumoto  <matz@net‐>.

December 31, 2002      Ruby Programmers Reference Guide		       RUBY(1)

List of man pages available for JazzOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net