Ruby Glossary S - Z

 $SAFE >= 1
 * The environment variables RUBYLIB and RUBYOPT
   are not processed,
   and the current directory is not added to the path.
 * The command-line options -e, -i, -I, -r, -s, -S, 
   and -x are not allowed.
 * Can't start processes from $PATH if any directory
   in it is world-writable.
 * Can't manipulate or chroot to a directory
   whose name is a tainted string.
 * Can't glob tainted strings.
 * Can't eval tainted strings.
 * Can't load or require a file whose name is a
   tainted string.
 * Can't manipulate or query the status of a file or
   pipe whose name is a tainted string.
 * Can't execute a system command or exec a program
   from a tainted string.
 * Can't pass trap a tainted string.

$SAFE >= 2
 * Can't change, make, or remove directories, or use chroot.
 * Can't load a file from a world-writable directory.
 * Can't load a file from a tainted filename starting with ~.
 * Can't use File#chmod, File#chown, File#lstat, 
   File.stat , File#truncate , File.umask , File#flock,
   IO#ioctl , IO#stat , Kernel#fork , Kernel#syscall ,
   Kernel#trap . Process::setpgid , Process::setsid ,
   Process::setpriority , or Process::egid= .
 * Can't handle signals using trap.

$SAFE >= 3
 * All objects are created tainted.
 * Can't untaint objects.

$SAFE >= 4
 * Can't modify a nontainted array, hash, or string.
 * Can't modify a global variable.
 * Can't access instance variables of nontainted objects.
 * Can't change an environment variable.
 * Can't close or reopen nontainted files.
 * Can't freeze nontainted objects.
 * Can't change visibility of methods
   (private/public/protected).
 * Can't make an alias in a nontainted class or module.
 * Can't get meta information (such as method or variable
   lists).
 * Can't define, redefine, remove, or undef a method in
   a nontainted class or module.
 * Can't modify Object.
 * Can't remove instance variables or constants from
   non-tainted objects.
 * Can't manipulate threads, terminate a thread other
   than the current, or set abort_on_exception.
 * Can't have thread local variables.
 * Can't raise an exception in a thread with a lower
   $SAFE value.
 * Can't move threads between ThreadGroups.
 * Can't invoke exit, exit!, or abort.
 * Can load only wrapped files, and can't include modules
   in nontainted classes and modules.
 * Can't convert symbol identifiers to object references.
 * Can't write to files or pipes.
 * Can't use autoload.
 * Can't taint objects.

$ - global
@ - instance
@@ - class

# double quotes - allows escaping
"variable is substitued #{myvar}"
"newline is substituted \n"
# single quotes - char escaping only
' variable is not substituted #{myvar}'
'escapes the \' single quote'
# % form %q(single quote) or $Q (double quote) 
# delimiters may be () [] {} <>
%Q("this is a string including double quotes)
# % x execute - sent to OS
%x[ps ax|more]
# %r - regex
# %w array 
myarray = %w[one two three]

# called with no params - 
# scans hierarchy looking for mmethod executes 
# then runs {local stuff}
 def mmethod
 super + {local stuff}
 end

# NOTE: integer 0 iterates zero times
3.times {|i| print i} # => 0 1 2

if x != y
end

# more sensibly written as

unless x == y
end

m  takes a base64 encoded string returns a string

# simple form
def thing
 yield
end

# caller 
obj.thing {do something}

# test for block
def thing
 if block_given? 
  yield
 else
 	puts "no block given"
 end
end

# caller 
obj.thing {do something}

# inside an iterator
def thing
 @myarray.each {|x| yield x}
end

# caller
obj.thing {|y| do something to y}
# block applied to each element of the array

# passing arguments to yield
def thing(p1,p2)
 if block_given?
  yield(p1,p2)
 else
  p1 + p2
 end
end

# caller
obj.thing(2,3) {|x,y| x*x + y*y } # => 13
obj.thing(2,3) # => 5

# internal arguments to yield
@attr = 5
def thing(p1)
 if block_given?
  yield(@attr,p1) # uses instance variable
 else
  @attr + p1
 end
end

# caller
obj.thing(2) {|x,y| x*x + y*y } # => 29
obj.thing(2) # => 7

# passing variable number of arguments to yield
# block made visible using & which creates Proc object
def thing(p1,p2,&bb)
 if block_given?
  if bb.arity == 2
	 yield(p1,p2)
  else
   yield(p1)
  end
 else
  p1 + p2
 end
end

# caller
obj.thing(2) {|x| x*x } # => 4
obj.thing(2,3) {|x,y| x*x + y*y } # => 13
obj.thing(2,3) # => 5