Bound i unbound method

Ruby pozwala na “wyciągnięcie” pojedynczej metody z obiektu w postaci obiektu Method, który można później wywołać. Ruby dostarcza dwa rodzaje metod - Method oraz UnboundMethod. Podstawową różnicą między tymi dwoma jest to, że Method możemy wywołać, a UnboundMethod nie. Spowodowane jest to tym, iż obiekt UnboundMethod nie ma zadeklarowanego odbiorcy metody. Obiekt UnboundMethod można oczywiście “przypiąć” do odpowiedniego obiektu, ale o tym za chwilę.

Na początek prosty przykład.

class Timmy
  attr_accessor :age

  def say
    "Timmy!"
  end

  def move(x)
    "Moved #{x} meters"
  end
end

timmy = Timmy.new

say_method = timmy.method(:say) # => #<Method: Timmy#say>
move_method = timmy.method(:move) # => #<Method: Timmy#move>

Metoda method(sym) jest zdefiniowana w klasie Object i dostępna we wszystkich obiektach. Zwraca obiekt Method z metodą o podanej nazwie. Metoda ma zadeklarowanego odbiorcę, tak więc można ją wykonać. Metody wykonuje się tak samo jak obiekty Proc czyli poprzez call(parametry).

say_method.call # => "Timmy!"
move_method.call(4) # => "Moved 4 meters"

Taki obiekt metody można “odczepić” od odbiorcy:

unbound_say = say_method.unbind # => #<UnboundMethod: Timmy#say>

Tak “odczepionej” metody nie można już wywołać:

unbound_say.call
NoMethodError: undefined method `call' for #<UnboundMethod: Timmy#say>
	from (irb):30

Innym sposobem na uzyskanie obiektu UnboundMethod jest pobranie metody proste z klasy.

unbound_method = Timmy.instance_method(:say) # => #<UnboundMethod: Timmy#say>

Taki obiekt można teraz “przypiąć” do odpowiedniego obiektu:

tim = Timmy.new
unbound_method.bind(tim) # => #<Method: Timmy#say>

Jednak przypinanie metody z klasy do obiektu tej samej klasy ma trochę mały sens. Jednak można to wykorzystać na przykład w celu wywołania metody nadnadklasy:

class Person
  def say
    "HELLO"
  end
end

class Kid < Person
  def say
    "Hi"
  end
end

class Jimmy < Kid
  def say
    "Jimmy!"
  end
end

jim = Jimmy.new
jim.say # => "Jimmy!"
jim.class.superclass.superclass.instance_method(:say).bind(jim).call # => "HELLO"

included, extended, inherited

Metody included, extended oraz inherited są (jak można się domyślić) wywoływane kiedy korzystamy z include, extend albo dziedziczenia.

Kiedy dziedziczymy po jakiejś klasie, wywoływana jest na niej metoda inherited (o ile została zadeklarowana):

class Car
  def self.inherited(base)
    puts "#{base} inherits from Car"
  end
end

class Mercedes < Car; end
class Audi < Car; end
class BMW < Car; end

# >> Mercedes inherits from Car
# >> Audi inherits from Car
# >> BMW inherits from Car

Daje to większe możliwości operacji na klasach pochodnych i pozwala na wykonanie dodatkowych operacji.

Kolejną i chyba najczęściej wykorzystywaną metodą jest included. Metoda ta dotyczy modułu, który jest “includowany”. Dzięki temu zamiast pisać:

class Audi
  include Fast::InstanceMethods
  extend Fast::ClassMethods
end

można to uprościć do zapisu:

class Audi
  include Fast
end

a całą resztę pozostawić modułowi:

module Fast
  def self.included(base)
    puts "#{base} includes Fast"
    base.send(:include, InstanceMethods)
    base.extend(ClassMethods)
  end

  module InstanceMethods
    def go
      "Goooooo #{self}"
    end
  end

  module ClassMethods
    def describe
      "I`m #{self}"
    end
  end
end

class Audi
  include Fast
end

class BMW
  include Fast
end

# >> Audi includes Fast
# >> BMW includes Fast

Audi.describe # => "I`m Audi"
BMW.describe # => "I`m BMW"
Audi.new.go # => "Goooooo #<Audi:0x241bc>"
BMW.new.go # => "Goooooo #<BMW:0x24090>"

Ostatnią metodą jest extended, która jest praktycznie identyczna w działaniu jak included z tym że jest wywoływana podczas użycia extend:

module Slow
  def self.extended(base)
    puts "Slow extends #{base}"
  end

  def describe
    "I`m slow #{self}"
  end
end

class Mercedes
  extend Slow
end

# >> Slow extends Mercedes

Mercedes.describe # => "I`m slow Mercedes"

Zarówno inherited jak i included są często wykorzystywane w przeróżnych bibliotekach. Przewagą dołączania modułu nad korzystaniem z dziedziczenia jest to, że moduł możną dołączyć praktycznie zawsze, podczas gdy ustawienie nadklasy nie zawsze jest możliwe.