• Още Интроспекция в Ruby
• Метапрограмиране!

• Липсващи методи и константи (method_missing и компания)
• Любопитни неща за обектния модел в Ruby
• define_method
• Всичките варианти на eval
• В дълбочина за обектния модел в Ruby
• Singleton класове

• Днес - ново предизвикателство
• Сряда - нова задача

• В края на месеца (вероятно на 27-ми)
• 30 въпроса, 45 минути
• Напомняме, че има два теста, носят по 30 точки всеки
• Вторият тест ще е в края на семестъра и/или по време на сесията

• Отиваме на K2
• Пригответе си зимната екипировка
• Ваксинирайте се, направете си застраховка живот
• Среща в 10:50 на спирката на автобус №3 до Метро (карта)
• Oбути подходящо, с дъждобранче (за всеки случай)
• Елате навреме, защото автобусът е през час и няма да чакаме закъснелите
• Ще пуснем новина и тема във форума с още детайли

"Premature optimization is evil."

• "Направи го да работи, после го направи бързо"
• Особено за скриптовите езици (в това число и Ruby)
• Benchmark or it didn't happen
• Но тест на реален код/ситуация, а не "синтетичен" бенчмарк

• Ruby ви дава възможност да се закачате на определени събития посредством hooks
• Обикновено във въпросните hooks може да промените нещото, което се случва, по някакъв начин
• Ще разгледаме някои hooks за събития, възникващи при промяна и изпълнение на код

• Можем да бъдем известени, че някой е добавил метод в модул или клас
• Това става като си дефинираме Module#method_added(method_name)
• Същото нещо, но за премахване на методи, е Module#method_removed(...)

• Kernel::singleton_method_added се вика, когато добавите класов метод в модул или клас
• Class#inherited се вика, когато вашият клас бъде наследен от друг клас
• Bar.included се вика, когато някой напише class Foo; include Bar; end
• Bar.extend_object се вика, когато някой напише class Foo; extend Bar; end
• Това не е изчерпателен списък

• В тези hooks получавате аргументи, които ви дават възможност да следите какво се случва
• Например името на добавен/премахнат метод, класът наследник, класът, който ви е include-нал и т.н.
• В тези моменти можете да извършите някакво допълнително действие, ако се налага
• Това е един от механизмите за създаване на любипитни, динамични разширения на езика

• Имаме възможност да правим някои неща с виртуалната машина (интерпретатора) на Ruby
• Да спрем събирането на боклука
• Модулът GC - интерфейс към mark-and-sweep garbage collector-а на Ruby
• GC.stop спира събирането на неизползвани обекти

GC.methods - Object.methods # [:start, :enable, :disable, :stress, :stress=, :count, :stat]
GC.constants                # [:Profiler]

• Kernel#set_trace_func(proc)
• Задава въпросния proc обкект като трасираща функция
• Параметри: име на събитие, файл, ред, object_id, binding, клас
• Понеже му давате proc, може да пропуснете някои от параметрите

• c-call - извикване на C-метод
• c-return - връщане от C-метод
• call - извикване на Ruby метод
• return - връщане от Ruby метод
• class начало на дефиниция на клас или модул
• end край на горната дефиниця
• line изпълняване на код на ред Х
• raise възникнало изключение

c-return t.rb:5   set_trace_func          Kernel
    line t.rb:7
  c-call t.rb:7        inherited           Class
c-return t.rb:7        inherited           Class
   class t.rb:7
    line t.rb:8
  c-call t.rb:8     method_added          Module
c-return t.rb:8     method_added          Module
     end t.rb:11
(Продължава на следващия слайд...)

(Продължение от предишния слайд...)
    line t.rb:13
  c-call t.rb:13             new           Class
  c-call t.rb:13      initialize     BasicObject
c-return t.rb:13      initialize     BasicObject
c-return t.rb:13             new           Class
    line t.rb:14
    call t.rb:8              bar             Foo
    line t.rb:9              bar             Foo
  return t.rb:10             bar             Foo

• Може да ползвате Kernel#trace_var, за да следите за промени по глобални променливи
• Важи само за "специални" глобални променливи, не за такива, дефинирани от вас

• Напомняме: третирайте всички техники, показани тук, като code smell
• Много е вероятно да има друг, по-прост, чист и елегантен дизайн, решаващ същия проблем
• Просто вие не сте го открили още; помислете добре, преди да прибегнете до тези техники
• Ползвайте ги само в краен случай, когато нямате избор

Метапрограмирането е писането на код, който пише друг код

meta- (also met- before a vowel or h)
combining form

1. denoting a change of position or condition : metamorphosis | metathesis.
2. denoting position behind, after, or beyond: : metacarpus.
3. denoting something of a higher or second-order kind : metalanguage | metonym.
4. Chemistry denoting substitution at two carbon atoms separated by one other in a benzene ring, e.g., in 1,3 positions : metadichlorobenzene. Compare with ortho- and para- 1 .
5. Chemistry denoting a compound formed by dehydration : metaphosphoric acid.

ORIGIN from Greek meta ‘with, across, or after.’

• Ако обект не отговаря на някакво съобщение, Ruby вика method_missing.
• Обикновено той е наследен от Object и хвърля NoMethodError.
• Можем да го предефинираме.
• Обикновено трябва да викнем super.
• Трябва да се прави внимателно, понеже има бая поле за грешка.

Има и коварни моменти:

class Hash
  def method_missing(name, *arg, &block)
    args.empty? ? self[name] : super
  end
end

things = {lion: 'Simba'}
things.lion# ~> -:3: stack level too deep (SystemStackError)

• Има typo - arg вместо args.
• args всъщност е self.args.
• Безкрайна рекурсия, anyone?

• Спомняте ли си respond_to?
• respond_to? не работи за методите, на които "отговаряте" през method_missing
• respond_to? вика respond_to_missing?, ако методът, за който питате, не е дефиниран
• Добра практика е да дефинирате respond_to_missing?, ако имате и method_missing

Нека имаме този клас:

class Student
  attr_accessor :name, :age, :faculty_number

  def initialize(**attributes)
    attributes.each do |name, value|
      send "#{name}=", value
    end
  end
end

average_joe = Student.new name: 'Joe', age: 33, faculty_number: '42042'
average_joe.name           # "Joe"
average_joe.age            # 33
average_joe.faculty_number # "42042"

Нека имаме списък с такива студенти:

students = [
  Student.new(name: 'Asya',   age: 6,  faculty_number: '12345'),
  Student.new(name: 'Stefan', age: 28, faculty_number: '666'),
  Student.new(name: 'Tsanka', age: 12, faculty_number: '42042'),
  Student.new(name: 'Sava',   age: 3,  faculty_number: '53453'),
]

И нека сме направили този monkey patch:

class Enumerator
  def extract(&block)
    each do |object|
      block.call object.send(block.parameters.first.last)
    end
  end
end

Тогава, можем да направим това:

students.map.extract { |name| name } # ["Asya", "Stefan", "Tsanka", "Sava"]
students.map.extract { |age| age }   # [6, 28, 12, 3]

students.each.extract do |faculty_number|
  puts faculty_number # Prints out 12345, then 666, then 42042, then 53453
end

• Представете си, че сте Java програмист...
• ...който наскоро е открил Ruby...
• ...и иска да направи социална мрежа за киномани.
• Решавате да започнете с клас, пазещ филм в БД

Тук имаше повторение.

• Има таблица movies с колона title и клас Movie с поле @title
• Стринговия литерал "title" се повтаря
• Двойката title() и title=() някак повтаря двойката director() и director=()
• Може би ставаме нагли, но низа "movies" изглежда повтаря, че класът се казва Movie

С малко метапрограмиране изглежда така:

class Movie < ActiveRecord::Base
end

Метапрограмирането е писането на код, което управлява конструкциите на езика по време на изпълнение

• Ще си говорим за различни похвати, с които това става
• За да разберем похватите, трябва да си говорим за някои детайли в Ruby
• Първият такъв е ОО моделът на Ruby

Доста просто:

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

• Всеки клас дефинира методи
• Тези методи са достъпни на инстанциите му
• Отделно, класът е обект...
• ...и има собствени методи
• Има разлика между методите на обекта клас и методите на неговите инстанции

Можете да вземете класа на всеки обект с Object#class.

"abc".class              # String
"abc".class.class        # Class
"abc".class.class.class  # Class

Можете да вземете родителския клас с Object#superclass.

class A; end
class B < A; end
class C < B; end

C.superclass                       # B
C.superclass.superclass            # A
C.superclass.superclass.superclass # Object

• Нали ви казах, че инстанциите пазят полета, пък класовете - методи?
• Е, модулите също пазят методи
• Всъщност, Class е наследник на Module
• Още Class.superclass == Module
• Още известно като Class < Module
• Спомнете си ancestor chain-а. Всичко в него е модул
• В Ruby, данните се пазят в обекти, а кодът - в модули

BasicObject идва в Ruby 1.9 и е много опростена версия на Object.

Подходящ е за method_missing магарии

Object.instance_methods.count      # 56
BasicObject.instance_methods.count # 8

m = BasicObject.instance_methods.join(', ')
m # "==, equal?, !, !=, instance_eval, instance_exec, __send__, __id__"

Което ни навежда на следващия въпрос - instance_eval

• Всеки Ruby израз има някакъв неявен self
• Този self се ползва за полета (@foo) и търсене на методи (bar()).
• Може да го наричаме "текущ обект"
• instance_eval променя self в рамките на един блок

instance_exec е като instance_eval, но позволява да давате параметри на блока.

obj = Object.new
set = ->(value) { @x = value }

obj.instance_exec(42, &set)

obj.instance_variable_get :@x  # 42
obj.instance_eval { @x }       # 42

Това е смислено, когато блока се подава с &. Иначе няма нужда.

• Освен текущ обект (self), има и текущ клас
• Това е класът, в който се дефинират методите с def
• Няма ключова дума, която да ви го покаже
• Следи се лесно
• Ключовите думи class и module го променят

class_eval променя self и текущия клас

def monkey_patch_string
  String.class_eval do
    self # String

    def answer
      42
    end
  end
end

"abc".respond_to? :answer # false
monkey_patch_string
"abc".respond_to? :answer # true

Module#module_eval е синоним на Module#class_eval.

• send
• method_missing
• define_method

С Class.new може да създадете анонимен клас

anonymous = Class.new do
  def answer
    42
  end
end

instance = anonymous.new
instance.answer # 42

anonymous # #<Class:0x42686108>

Ако присвоите Class.new на константа, стават магии

first  = Class.new {}
SECOND = Class.new {}

first  # #<Class:0x4230a1a0>
SECOND # SECOND

Името на класа се променя. Любопитно.

Прави същото като Class.new, ама с модул

eval(text) изпълнява код в низ

things = []
eval 'things << 42'
things    # [42]

• Всеки Ruby израз има достъп до някакви променливи
• Сборът от тези променливи се нарича "binding"
• Това е доста популярна думичка
• Можете да вземете обект, който представлява binding
• И да изпълнявате код върху него

• Най-просто, това е лексикалният scope в момента
• Всеки блок вижда променливите в блока, в който се съдържа
• Ако блокът дефинира нова променлива, тя не отива в "родителските" му блокове
• Ако промени текуща променлива, промяната остава
• Помните ли scope gate-овете?

module, class и def секват binding-а

top_level = 1
module Something
  in_module = 2
  class Other
    in_class = 3
    def larodi
      top_level # error: NameError
      in_module # error: NameError
      in_class  # error: NameError
    end
  end
end

Something::Other.new.larodi

Scope gate-овете могат да се заобиколят с define_method, Class.new и Module.new.

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