Tech Stuff - Ruby Glossary A - D

# either use as section separator (no parameter)
public
protected
private
# terminate section with 'end'

# OR with symbol parameter
# must come AFTER the method definition
public :method1, :method2 # etc
protected :method3, :method4 # etc
private :method5, :method6 # etc
# for Class methods use
private_class_method

attr_reader :thing #get only
attr_writer :thing #set only
attr_accessor :thing #get and set 
attr: thing [,true] # short form of attr_accessor

# the last form with the optional [,true] is meant to indicate
# it provides attr_accessor proeprties otherwise attr_reader
# properties - testing suggests this is not the case and 
# that in all cases attr_accessor characteristics are provided.

# OR roll-your-own 
def thing # get
 do something  # compute response OR
 @thing # return stored value
end

def thing=(thingie) # set
 do something to thingie # compute value OR
 @thing = thingie
end

attr_writer and attr_accessor both create an instance variable of the form @thing if not defined but which is obviously(!) only valid after it has been set. The form attr :thing, true is equivalent to attr_accessor :thing

# either use as section separator (no parameter)
alias alias_name current_name
# must come AFTER the current_name method

ar = Array.new() # empty array
ar = [] # empty array

# optional size, default value arguments
# default value is returned for any element which 
# has not been assigned
ar = Array.new(2, "a") # ["a", "a"]
ar = Array.new(2) # [nil, nil]

# initialising with values
ar = ["a", "a"] 
ar = Array.[]("a", "a")
ar = Array["a", "a"]

# mixed values
ar = [1, "a", 2, 3]
ar << 1 # => [1, "a", 2, 3, 1]

# multiple assignment - same value
a = b = 1

# multiple assigment - multiple values
a,b,c = "one", "two", "three"

# using C style conditional expression to set value
msg = ok.empty? ? "yes" ; "no"

# condition result to set value
msg = if ok.empty? then "yes" else "no" end

...
begin
# buggy code!
..
rescue SomeError
  some code
end

# def has implicit begin-end so this works
def method
  buggy code!
  ...
  rescue SomeError
    some code
end

BEGIN {code block}

# method generates one of two results depending 
# on presence or absence of block
 def somemethod(p1,p2)
  if block_given?  
    yield(p1,p2)
  else
   p1 + p2
 end

# call with only arguments
somemethod(2,3) # => 5

# call with block
somemethod(2,3) {|x,y| x*x + y*y} # => 13

# simple class definition
class Thing
 ...
end

# class extends (includes all methods of) Another class
class Thing < Another

# test for single char in string
if string[0].chr == "a" then do something end
# OR functionally identical
if string[0] == "a"[0] then do something end

and   (synonym &&) 
or    (synonym ||)
not   (synonym !)
==    Test for equal value. 
===   Used to test equality within a when clause of 
      a case statement. 
<=>   General comparison operator.
      Returns -1, 0, or +1, depending on whether 
      its receiver is less than, equal to, or
      greater than its argument. 
<, <=, >=, >  Comparison operators for less than,
      less than or equal, greater than or equal, 
      and greater than. 
=~    Regular expression pattern match. 
eql?  True if the receiver and argument have both the
      same type and equal values. 1 == 1.0 returns true,
      but 1.eql?(1.0) is false. 
equal? True if the receiver and argument have the same 
       object id

# newarray == other array with 1 added to each element
newarray = old array.collect {|a| a+1}

# definition of a empty instance method
class Thing
 def my_method
 ...
 end
end
 
# instance method with arguments
class Thing
 def another_method arg1, arg2
# or def another_method (arg1, arg2)
 ...
 end 
end

# instance method use
a = Thing.new
a.another_method(p1,p2) # => some result

# defining a class method
class Thing
 def self.class_method(arg1,arg2)
 ...
 end
end

# usage of class method
Thing.class_method(p1,p2) # => some result

# empty arguments
 def somemethod
  ...
 end
 
# variable name arguments
 def somemethod(p1,p2)
  ...
 end
 
# method call 
 somemethod(1,2)
# or by using an * in the call arguments can be 
# exploded from an array
# the following is functionally identical to above
 somemethod (*[1,2])
 
# variable name arguments with defaults
# any or all arguments may have defaults
# evaluated left to right and may reference preceding 
# argument values
 def somemethod(p1,p2=1,p3=p1+1)
  ...
 end

# array arguments collection
# adding * to argument name collects into an array 
# which must be last or only argument
# NOTE: any argument can also be an array, this form just uses
#       implicit collection of arguments into an array at the
#       time of the method call
 def somemethod(p1,*p2)
  ...
 end

# adds all excess arguments to p2 array above
# 2 and 3 below are placed in array
somemethod (1,2,3) # p1 = 1, p2 = [2,3]

# hash collection of arguments
# used as a type of keyword argument
 def somemethod(p1,p2)
  ..
 end

# hash collector shortform for p2 above
# does not need normal brace syntax
somemethod (1,"one" => 1, "two" =>2)

# but could also be written as 
somemethod (1,{"one" => 1, "two" =>2})

# code block argument
# adding & before argument indicates code block
# all methods can be called with an optional code block 
# (see here)
# this syntax causes a Proc class object to be created
# automatically giving access to all Proc methods

# example generates one of three results depending 
# on presence or absence of block and no. of block arguments
 def somemethod(p1,p2,&p3)
  if block_given?  
   if p3.arity == 1 # .arity returns count 
                    # of arguments in block
    yield(p1)
   else
    yield(p1,p2)
   end
  else
   p1 + p2
 end

# call with only arguments
somemethod(2,3) # => 5
# call with block and two arguments
somemethod(2,3) {|x,y| x*x + y*y} # => 13
# call with block and one argument
somemethod(2,3) {|x| x*x} # => 4

defined? thing # => nil does not exist
# if it does exist, may return one of:
# expression, super, assignment, method, 
# yield, self, nil, true, false, assignment,
# local-variable, local-variable(in-block)
# global-variable, instance-variable, constant,
# class variable