class Module

def delegate(*methods)


Foo.new.zoo # returns nil

end
delegate :zoo, :to => :bar, :allow_nil => true
end
@bar = bar
def initialize(bar = nil)
attr_accessor :bar
class Foo

Foo.new.zoo # raises NoMethodError exception (you called nil.zoo)

end
delegate :zoo, :to => :bar
end
@bar = bar
def initialize(bar = nil)
attr_accessor :bar
class Foo

+nil+ instead with the +:allow_nil+ option.
no matter whether +nil+ responds to the delegated method. You can get a
If the delegate object is +nil+ an exception is raised, and that happens

invoice.customer_address # => "Vimmersvej 13"
invoice.customer_name # => "John Doe"
invoice = Invoice.new(john_doe)

end
delegate :name, :address, :to => :client, :prefix => :customer
class Invoice < Struct.new(:client)

It is also possible to supply a custom prefix.

invoice.client_address # => "Vimmersvej 13"
invoice.client_name # => "John Doe"
invoice = Invoice.new(john_doe)
john_doe = Person.new("John Doe", "Vimmersvej 13")

end
delegate :name, :address, :to => :client, :prefix => true
class Invoice < Struct.new(:client)

Person = Struct.new(:name, :address)

delegated to.
is true, the delegate methods are prefixed with the name of the object being
Delegates can optionally be prefixed using the :prefix option. If the value

Foo.new.max # => 11
Foo.new.min # => 4
Foo.new.sum # => 6

end
delegate :max, :to => :@instance_array
delegate :min, :to => :@@class_array
delegate :sum, :to => :CONSTANT_ARRAY
end
@instance_array = [8,9,10,11]
def initialize

@@class_array = [4,5,6,7]
CONSTANT_ARRAY = [0,1,2,3]
class Foo

by providing them as a symbols:
Methods can be delegated to instance variables, class variables, or constants

Foo.new.goodbye # => "goodbye"

end
delegate :hello, :goodbye, :to => :greeter
belongs_to :greeter
class Foo < ActiveRecord::Base

Multiple delegates to the same target are allowed:

Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #
Foo.new.hello # => "hello"

end
delegate :hello, :to => :greeter
belongs_to :greeter
class Foo < ActiveRecord::Base

end
end
"goodbye"
def goodbye

end
"hello"
def hello
class Greeter < ActiveRecord::Base

Delegation is particularly useful with Active Record associations:

or string). At least one method and the :to option are required.
and the name of the target object via the :to option (also a symbol
as your own. Pass one or more methods (specified as symbols or strings)
Provides a delegate class method to easily expose contained objects' methods 
def delegate(*methods)
  options = methods.pop
  unless options.is_a?(Hash) && to = options[:to]
    raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
  end
  prefix, to, allow_nil = options[:prefix], options[:to], options[:allow_nil]
  if prefix == true && to.to_s =~ /^[^a-z_]/
    raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
  end
  method_prefix =
    if prefix
      "#{prefix == true ? to : prefix}_"
    else
      ''
    end
  file, line = caller.first.split(':', 2)
  line = line.to_i
  methods.each do |method|
    method = method.to_s
    if allow_nil
      module_eval(<<-EOS, file, line - 2)
        def #{method_prefix}#{method}(*args, &block)        # def customer_name(*args, &block)
          if #{to} || #{to}.respond_to?(:#{method})         #   if client || client.respond_to?(:name)
            #{to}.__send__(:#{method}, *args, &block)       #     client.__send__(:name, *args, &block)
          end                                               #   end
        end                                                 # end
      EOS
    else
      exception = %(raise "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
      module_eval(<<-EOS, file, line - 1)
        def #{method_prefix}#{method}(*args, &block)        # def customer_name(*args, &block)
          #{to}.__send__(:#{method}, *args, &block)         #   client.__send__(:name, *args, &block)
        rescue NoMethodError                                # rescue NoMethodError
          if #{to}.nil?                                     #   if client.nil?
            #{exception}                                    #     # add helpful message to the exception
          else                                              #   else
            raise                                           #     raise
          end                                               #   end
        end                                                 # end
      EOS
    end
  end
end