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

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

• Четвърта задача е на линия от днес сутринта
• Срокът е до идната сряда, 17:00
• Засяга една от силните страни в Ruby – DSL-и (domain specific languages)
• Ако не ви е ясно как да подходите, минете внимателно лекциите от понеделник и от днес

• Планираме да ви дадем още едно или две предизвикателства идните дни
• Целта ще бъде упражнение на наученото за метапрограмиране
• Косвено – помощ за четвърта задача

Как Ruby пази полета и методи?

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

Кой е класът на "foo"? На Integer? На Class?

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

"foo".class == String  # true
Integer.class == Class # true
Class.class == Class   # true

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

Какво прави instance_eval?

Изпълнява блока с променен self.

Как 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', можем ли динамично да създадем такъв метод? Как?

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

  # Dynamically define a first_name "getter"?
end

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:0x412a7588>>
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:0x42226cfc>>
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]

Помните ли 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 са просто методи, викащи се на определени обекти.

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

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

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

Метакласът на суперкласа е суперкласът на метакласа.

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

∎

• Викайки метод на произволен обект 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]

• Избягвайте помощни методи при monkey patching
• Ако слагате такива, поне ги направете private
• Може да ползвате и локална lambda/proc в кода на метода си
• Условието "enumerator ако няма блок": some_collection.each(&block)
• String#split(//) vs. String#chars – кое е по-ясно?

• Лекция за Git - разберете архитектурата, за да разберете инструмента
• Лекция за Регулярни изрази

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