Blockiness

e = "Something"
["hi",98,:bar].each do |e|
  puts e
end

• Blocks encapsulate code and can use (and clobber!) the variables from the surrounding code
• They are often used for iteration
• retry causes the block to run again with the same arguments
• next ends this run of the block
• break ends this run and the method calling the block

Yielding and Calling

def attend_sessions(*sessions)
  i = 0
  sessions.each do |s|
    puts "Attending session #{i}: #{s}"
    yield s
  end
end

• Blocks are objects, too
• You can explicitly access this object, like so:

def attend_sessions(*sessions, &block)
    # same code
    block.call s
    # same code
end

Getting Classy

class BarCamp
  DEFAULT_FUN = 10**6
  def initialize
    @fun = DEFAULT_FUN
  end
  def bored_attendees(num)
    @fun = DEFAULT_FUN - 100*num
  end
  def is_boring?
    @fun < 1000
  end
end
event = BarCamp.new
event.bored_attendees 10
event.is_boring?

Subclassing

class Hero
  def save(name)
    "Doing CPR on #{name}"
  end
  def is_awesome?
    true
  end
end

class SuperHero < Hero
  def initialize(*ps)
    @powers = ps
  end
  def save(victim, villain)
    "Rescuing #{victim} from #{villain}"
  end
  def powers
    @powers
  end
end
sally = Hero.new
flash = SuperHero.new "Super speed", "Chemistry"

Exceptional Circumstances

• Catching Exceptions:

  begin
    1/0
  rescue Exception => e
    puts "Caught Exception!"
    puts e
  finally
    puts "This is always printed"
  end

• throw obj will throw any object as an exception
• raise MyExceptionClass, arg, backtrace will create and throw a MyException with arg and print backtrace instead of the actual trace. all arguments are optional
• raise with no arguments within a rescue block will re-raise the exception that was caught

Modules

• Provide a namespace for constants and "objectless"-methods
• Store methods for mixing into classes
• The mixing of methods provides something like multiple inheritance
• Can be used for interfaces, but with code!
• include other modules
• Usually assigned to constants, like classes

Mixing In Comparisons

class Lame
  include Comparable
  def <=>(o)
    3 <=> o
  end
end

• Comparable provides all other comparison operators, based on the definition of <=>

Modularizing Your Code

module CrookedVein
  include Comparable
  BUDGET = 500_000_000
  def self.publish
    puts "Here's a book"
  end
  def investigate
    # do stuff
  end
end

• CrookedVein::BUDGET → 500000000
• CrookedVein.publish prints "Here's a book"
• If a class include CrookedVein, then it's instances will have an investigate method
• Everything that includes CrookedVein, then it also acquires comparison operators (from Comparable)

Order in the Hierarchy

• Classes are searched, going up the inheritance chain
• Modules are searched in the reverse order they were included (so modules included later override those included earlier)
• If a module includes other modules, they're also searched (in the same order)
• No need to hunt through code, AClass.ancestors will show you the order
• 1.class.ancestors → [Fixnum, Integer, Precision, Numeric, Comparable, Object, Kernel]

Relationships and Divisions

• (Almost) everything in Ruby is an Object
• A module is Object that can hold methods for instances and act as a namespace
• Classes are modules that can be instantiated and derived from (but not included)
• Every Object has a class (some_obj.class). Modules are instances of Module and classes are instances of Class
• You can determine if something is an instance of a class using "".is_a? Object → true
• You don't need instances to tell if two things are related Fixnum < Numeric → true

Is That Code?

class Address
  # getter
  def number
    @number
  end
  # setter
  def number=(n)
    @number = n
  end
  attr_accessor :street, :city, :state
end

• attr_accessor makes setters and getters for you
• However, it's not magic; it's a method - a class method
• This means that the class definition is live code

Metaprogramming

class Barker
  def self.sayer(meth_name)
    define_method meth_name do
      puts "#{meth_name}!!"
    end
  end
  sayer :hey
  sayer :stop!
end
b = Barker.new
b.hey
b.stop

What am I?

• self has been used a lot to add methods
• self is an Object but objects can't have methods
• ... there must be "hidden" Class that the methods are added to
• It's called a metaclass or singleton
• self.sayer wasn't a method in the Class itself, but in it's metaclass

Cracking it Wide Open

o = Object.new
def o.works
  "This works"
end
class << o
  MY_CONST = 3
  def also
    "This works too, and gives more access"
  end
  # no access to outside variables :(
end
some_var = 2
(Foo = Module.new).module_eval do
  define_method "Some#{some_var}" do
    "This is Some#{some_var}"
  end
end

More Madness

• class Foo < some_method() is valid
• If you have multiple classes or modules that need the same methods, don't duplicate code between them
• class Bar < Module is valid
• Metaclasses can include Modules, just like normal classes
• Class, Modules, and metaclasses can all be modified at runtime
• There are even callbacks (see method_added and method_missing)