• Метапрограмиране
• Още метапрограмиране
• Още за обектния модел на Ruby
• Споменахме ли метапрограмиране?

• На 2 декември, вместо лекция; ще бъдете разделени на две групи
• 30 затворени въпроса, 45 минути; верен отговор = 1 т.; грешен = 0 т.
• Ще включва материал, предаден до 1 декември, включително
• Има два теста, носят по максимум 30 точки всеки
• Вторият тест ще е в края на семестъра и/или по време на сесията

• В понеделник ще говорим или за Git, или за тестване
• В сряда, 25 ноември, няма да имаме лекция – официален неучебен ден е
• Други промени в програмата към момента няма

Кажете ми всичко, което знаете за instance променливите.

Кой е класът на {}? На Integer? На Class?

Кой е родителят на String? На Object? На Class?

{}.class == Hash       # => true
Integer.class == Class # => true
Class.class == Class   # => true

String < Object        # => true
Object < BasicObject   # => true
Class < Module         # => true

Какво прави instance_eval? Ами instance_exec?

Изпълнява блока с променен self. instance_exec е същото, но може да подава аргументи на блока си.

Как Ruby знае къде да постави метод, дефиниран с def?

Винаги има текущ клас, в който този метод отива. Той може да се промени с module, class и class_eval. Всъщност, дори с instance_eval, но за това — по-късно.

Можем ли да направим така, че вместо изключения, несъществуващи локални променливи или методи да резултират в nil? Как?

foo          # => nil
foo.bar.baz  # => nil

class BasicObject
  def method_missing(*) end
end

Ако имаме името на метод в променлива, например method_name = 'first_name', бихме могли да ползваме define_method, за да създадем динамично метод:

class MyObject
  method_name    = 'first_name'
  implementation = -> { @data_store['first_name'] }

  define_method(method_name, &implementation)
end

• method_missing
• instance_eval/class_eval
• define_method
• Схемата на OO модела в Ruby

Може да (пре)дефинирате метод в конкретен обект.

things = [22, :f, 'Sofia']

def things.size
  -5
end

def things.asl
  "#{self[0]}/#{self[1]}/#{self[2]}"
end

things        # => [22, :f, "Sofia"]
things.size   # => -5
things.length # => 3
things.asl    # => "22/f/Sofia"

[].asl        # => error: NoMethodError
[].size       # => 0

• Само модули могат да съдържат методи
• Когато дефинирате метод на конкретен обект, Ruby го добавя в специален клас за този обект
• Всеки обект има специален клас, наречен singleton class, който съдържа уникалните за него методи
• Горното е полу-истина. Такъв клас се създава само ако има нужда
• Известен е още като metaclass, eigenclass и "собствен клас"

Собственият клас е достъпен чрез #singleton_class

things = []

def things.answer
  42
end

things.singleton_class
# => #<Class:#<Array:0x002b572f8bc548>>
things.singleton_class.instance_methods(false)
# => [:answer]
[].singleton_class.instance_methods(false)
# => []

Целите числа и символите нямат собствени класове. Това е заради специалното им вътрешно представяне в Ruby.

1_000.singleton_class # => error: TypeError
:blah.singleton_class # => error: TypeError

Можете да отворите собствения клас на обект с class <<

things = [22, :f, 'Sofia']

class << things
  def size
    -5
  end

  def asl
    "#{self[0]}/#{self[1]}/#{self[2]}"
  end
end

things.asl  # => "22/f/Sofia"
things.size # => -5

Оригиналният метод е достъпен чрез super.

Някой има ли идея защо super работи?

things = []

def things.answer
  42
end

things.singleton_class # => #<Class:#<Array:0x002b91ce2dc478>>
things.singleton_class.superclass # => Array

Ще продължим с преглед отвътре на "класовите" методи.

Вероятно помните, че класови методи могат да се дефинират така:

class Something
  def Something.foo() 42 end
  def self.bar() 42 end

  class << self
    def qux() 42 end
  end
end

Класовите методи се пазят в собствения клас на класа

class Something
  def self.answer() 42 end
end

Something.singleton_class # => #<Class:Something>
Something.singleton_class.instance_methods(false) # => [:answer]

class Something; end

Something.instance_eval do
  def say_something() 'something' end
end

Something.say_something # => "something"
Something.new.say_something # => error: NoMethodError

• Горното е същото като def Something.say_something() 'something' end
• self == Something
• Текущият клас е singleton класът на Something
• Дефинициите в instance_eval дефинират методи върху singleton класа

class Something; end

Something.class_eval do
  def say_something() 'something' end
end

Something.say_something # => error: NoMethodError
Something.new.say_something # => "something"

• Горното е същото като class Something; def say_something() 'something' end end
• self == Something
• Текущият клас е Something
• Дефинициите в class_eval дефинират методи върху самия клас

Помните ли extend?

module Knowledge
  def answer() 42 end
end

class Something
  extend Knowledge
end

Something.answer # => 42

module Knowledge
  def answer() 42 end
end

text = "fourty-two"
text.extend Knowledge

text.answer # => 42

Сещате ли се как може да се имплементира?

module Knowledge
  def answer() 42 end
end

class Something; end

Something.singleton_class.include Knowledge

Something.answer # => 42

Изводи:

• - include и extend са просто методи, викащи се на определени обекти
• - obj.extend(foo) ≃ obj.singleton_class.include(foo)

Ще продължим да дълбаем в класовите методи при наследяване.

Класовите методи на родителя са достъпни в класовите методи на наследника:

class Something
  def self.answer() 42 end
end

class Other < Something
  def self.better_answer() answer * 2 end
end

Other.better_answer # => 84

Собственият клас на наследника наследява собствения клас на родителя:

class Something; end
class Other < Something; end

Something.singleton_class        # => #<Class:Something>
Other.singleton_class.superclass # => #<Class:Something>

Something.singleton_class == Other.singleton_class.superclass # => true

Singleton класът на суперкласа е суперкласът на singleton класа.

• Това продължава още едно ниво нагоре – до BasicObject и неговия singleton клас
• Singleton класът на BasicObject наследява от Class
• Тук "цикълът" се затваря и нещата започват да изглеждат както при singleton класове на обикновени обекти
• Обърнете внимание на разликата в родителя на singleton класа при обикновени обекти и при обекти тип "клас"
• При класове (които също са обекти), йерархията е по-различна

• Викайки метод на произволен обект object, Ruby го търси в object.singleton_class.ancestors
• Тоест, за всеки инстанционен метод, в това число и "класовите", се гледа ancestor chain-а на singleton класа на обекта
• А класовите методи са просто инстанционни методи и инстанцията е обектът от тип "клас"
• Толкова просто е

Относно търсенето на (инстанционни) методи на обектите от тип String:

''.singleton_class.ancestors
# => [#<Class:#<String:0x007f8788e51bd8>>,
#     String, Comparable, Object, Kernel, BasicObject]

''.class.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]

String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]

По отношение на "класовите" методи, викани върхy String:

String.singleton_class.ancestors
# => [#<Class:String>, #<Class:Object>, #<Class:BasicObject>,
#     Class, Module, Object, Kernel, BasicObject]

String.class.ancestors
# => [Class, Module, Object, Kernel, BasicObject]

Class.ancestors
# => [Class, Module, Object, Kernel, BasicObject]

1. Има само един вид обекти - били те обикновени или модули
2. Има само един вид модули - били те обикновени или клас
3. Има само един вид методи - живеят в модули, които често са класове
4. Всеки обект има "реален клас" - бил той обикновен клас или собствен клас
5. Всеки клас има точно един суперклас - с изключение на BasicObject
6. Суперкласът на singleton класа на обект е класът на обекта. Суперкласът на singleton класа на клас е singleton класът на родителя на класа.
7. При извикване на метод, Ruby взема "реалния клас" и търси в неговия ancestor chain

∎

• http://fmi.ruby.bg/
• @rbfmi