Tech Stuff - Ruby Glossary E - L

thing = ""
thing.empty? # => true i
thing = []
thing.empty? # => true

# to test if a variable exists 
defined? name # => nil if not defined else a text description.

def my_method (p1)
 ...
end

END {code block}

collect, detect, each_with_index, entries, find,
# find_all, grep, include?, map, max,
# member?, min, reject, select, sort, to_a

miobj = "Thing.new"
mithing = eval(miobj)
# is exactly equivalent to
mithing = Thing.new

When all else fails eval usually works. A real life example using FileUtils.rb

# File (FileTest) test
File.exist?("/path/to/file/or/directory") # => true if exists

# StringScanner
# test whether a string exists but does not 
# change current string pointer (predictive operation)
s = StringScanner.new('test string')
s.exist? /s/            # -> 3
s.scan /test/           # -> "test"
s.exist? /s/            # -> 6
s.exist? /e/            # -> nil

exit [defaults to 0]
exit(0)
# the optional exit condition by POSIX convention
# is 0 = OK (good status) and > 0 indicates an error state.
# The value of the error state is defined by the 
# application/script as a diagnostic aid

# creates an Exception object supplies associated text
raise "ouch"

begin 
...
some buggy code
...
# rescues all errors
rescue {code block}
# or rescue only [errortype] e.g StandardError
rescue [errortype]
 {code block}
# display any text associated
rescue StandardError => ouch
print ouch
ouch.backtrace.each {|x| print x}

ensure {code block}
end

module Something
 def some_method
  do thing
 end
end

# class Thing - may be defined in this file or another
class Thing
 
 include Something # includes the module and its methods
                   # as mixins
 extend Something  # methods of Something become class
                   # methods of Thing
 # instance methods of class
 def stuff
  ...
 end
end

# invoke as a class method
Thing.some_method

# using extend for instances
module SomethingElse
 def some_method
  do thing
 end
end

# class Thingie - may be defined in this file or another
class Thingie

 # instance methods
 def ...
 end
end

# adding mixin to an instance of Thingie
a = Thingie.new
a.extend(SomethingElse)
a.some_method # works
b = Thingie.new
b.some_method # fail, no method error

 r - Read-only, starts at beginning of file  (default mode).
 r+ - Read-write, starts at beginning of file.
 w - Write-only, truncates existing file
     to zero length or creates a new file for writing.
 w+ - Read-write, truncates existing file to zero length
      or creates a new file for reading and writing.
 a - Write-only, starts at end of file if file exists,
     otherwise creates a new file for writing.
 a+ - Read-write, starts at end of file if file exists,
      otherwise creates a new file for reading and
      writing.
 b - (DOS/Windows only) Binary file mode (may appear with
     any of the key letters listed above).

# file access - close/autoclose
# line level access - no autoclose
mf = File.open("myfile")
mf.each {|x| print x}
f.close # no autoclose

# file level access - autoclose
mf = file.open("myfile") do |file|
	mf.readlines.each {|x| print x}
end
# IO versions always autoclose
IO.foreach("myfile") {|x| print x}
IO.readlines("myfile").each {|x| print x}
ma = IO.readlines("myfile")

a = myarray.first
a = myarray[0]

# class instance method format
class Thing
  def mymethod(px)
    do something
  end
  
  def some(p1)
	 mymethod(p1+1) # call method from within class
  end
end

obj = Thing.new
obj.mymethod(p1)

# function format (private method of class Object)
# or written in-line function
# MUST be defined before call
# separate namespace inside def limits
  ...
  some code
  ...
  # function definition - not executed in-line
  def mymethod(px) # private method
    do something
  end
  ...
  some more code
# function call (call private method)
  mymethod(p)
  ...

$SAFE safety level - can be read and written(values)
$& copy of string from last pattern match
$+ The contents of the highest-numbered group 
   matched in the last successful pattern match 
   in "cat" =~/(c|a)(t|z)/, $+ will be 
   set to ``t''.
$` The string preceding the match in the last 
   successful pattern match
$' The string following the match in the last
   successful pattern match
$= If not nil or false, pattern matches will 
   be case insensitive
$1 contents of successive groups matched in
   the last successful pattern match
   In "cat" =~/(c|a)(t|z)/, 
   $1 will be set to ``a'' 
   and $2 to ``t''
$~ An object that encapsulates the results of 
   a successful pattern match variables 
   $&, $`, $', and $1 to $9 are 
   all derived from $~ Assigning to $~  changes 
   the values of these derived variables
$/ The input record separator (newline by default)
   If NIL whole file will be read
$-0 Synonym for $/
$, FS field separator
$\ RS record separator
$_ last line read by gets and readline
$: library path (used by require, load etc)(array)
$; default separator used by String#split
$< alias for ARGF
$! last exception
$@ last stack backtrace
$. line number in current file (last read)
$> destination for print & printf (default 
   value is $stdout)
$defout alias for $>
$-F alias for $;
$stderr
$stdin
$stdout 
$0 program name
$* command line options (alias ARGV)
$" array of 'load'ed items
$$ process number (pid)
$? exit status of last child
$-a true if -a option on cml
$-d alias for $DEBUG
__FILE__ name of current source file
$DEBUG true if -d cml option used
$F array contains lines if -a cml option (split input)
$FILENAME current input filename
$-I alias for $:
$-i name of back-up file
$-K multibyte coding system
$-L true if -l cml option set
__LINE__ current line number
$LOAD_PATH alias = $:
$-p true if -p option on cml
$VERBOSE true if -v option additional diagnostics
$-v alias for $VERBOSE
$-w alias for $VERBOSE
# SPECIAL GLOBALS
ARGF (alias = $<) command line pseudo-file 
     (behaves like IO object)
ARGV (alias = $*) array of command line arguments
DATA  The file object of the script,
#     pointing just after __END__.
ENV   hash of environmental variables
FALSE         false
NIL           nil
RUBY_PLATFORM current platform
RUBY_RELEASE_DATE version release date
RUBY_VERSION  current ruby version
STDIN         Standard input - default for $stdin.
STDOUT        Standard output - default for $stdout.
STDERR        Standard error output - default for $stderr.

a = {"one" => 1, "two" => 2}
a.has_key?("two") # => true
a.has_key?("three") # => false

a = {"one" => 1, "two" => 2,"three"=> "three"}
a.has_value?(1) # => true
a.has_value?(3) # => false
a.has_value?("three") # => true

Myvar = :myvar
print Myvar.id2name # => "myvar")

# single line - then essential in this form
if x == y then print x end
# multi-line - then not essential
if x == y
 print x
end
# multiple tests on multiple lines does not
# need then
if x == y
	do something
elsif x == z
	do somethingelse
else
	get lost
end
# if on single lines does 
# need then
if x == y then do something
elsif x == z then do somethingelse
else then do squat
end

unless can replace if in any expression if it helps readability or makes more sense.

# no separator
arr = ["1","2"]
arr.join # => "12"

# with separator
arr = ["1","2"]
arr.join("-") # => "1-2"

module Something
 def a_method
 end
end

# a_method is available to class Thing
class Thing
 include Something
end

module A
end

class B
  include A
end

class C < B
end

B.include?(A)   #=> true
C.include?(A)   #=> true
A.include?(A)   #=> false

# single line (delimited with braces)
obj.each {|val| something to val}
# multi-line (delimited with end)
obj.each do |val|
  something to val
end

a = myarray.last
a = myarray[myarray.size]